Debian Codegraph @

atasmart.c

raw ◀ ▶
Source reconstructed at patch state 0 of 2 — not the installed (fully patched) source.
2 Debian patches touch this file
1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
2
3 /***
4 This file is part of libatasmart.
5
6 Copyright 2008 Lennart Poettering
7
8 libatasmart is free software; you can redistribute it and/or modify
9 it under the terms of the GNU Lesser General Public License as
10 published by the Free Software Foundation, either version 2.1 of the
11 License, or (at your option) any later version.
12
13 libatasmart is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public
19 License along with libatasmart. If not, If not, see
20 <http://www.gnu.org/licenses/>.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <arpa/inet.h>
28 #include <stdlib.h>
29 #include <alloca.h>
30 #include <assert.h>
31 #include <fcntl.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <sys/stat.h>
37 #include <sys/ioctl.h>
38 #include <scsi/scsi.h>
39 #include <scsi/sg.h>
40 #include <scsi/scsi_ioctl.h>
41 #include <linux/hdreg.h>
42 #include <linux/fs.h>
43 #include <sys/types.h>
44 #include <regex.h>
45 #include <sys/param.h>
46 #include <libudev.h>
47
48 #include "atasmart.h"
49
50 #ifndef STRPOOL
51 #define _P(x) x
52 #endif
53
54 #define SK_TIMEOUT 2000
55
56 typedef enum SkDirection {
57 SK_DIRECTION_NONE,
58 SK_DIRECTION_IN,
59 SK_DIRECTION_OUT,
60 _SK_DIRECTION_MAX
61 } SkDirection;
62
63 typedef enum SkDiskType {
64 /* These three will be autotested for: */
65 SK_DISK_TYPE_ATA_PASSTHROUGH_12, /* ATA passthrough over SCSI transport, 12-byte version */
66 SK_DISK_TYPE_ATA_PASSTHROUGH_16, /* ATA passthrough over SCSI transport, 16-byte version */
67 SK_DISK_TYPE_LINUX_IDE, /* Classic Linux /dev/hda ioctls */
68
69 /* These three will not be autotested for */
70 SK_DISK_TYPE_SUNPLUS, /* SunPlus USB/ATA bridges */
71 SK_DISK_TYPE_JMICRON, /* JMicron USB/ATA bridges */
72 SK_DISK_TYPE_BLOB, /* From a file */
73 SK_DISK_TYPE_NONE, /* No access method */
74 SK_DISK_TYPE_AUTO, /* We don't know yet */
75 _SK_DISK_TYPE_MAX,
76 _SK_DISK_TYPE_TEST_MAX = SK_DISK_TYPE_SUNPLUS /* only auto test until here */
77 } SkDiskType;
78
79 #if __BYTE_ORDER == __LITTLE_ENDIAN
80 #define MAKE_TAG(a,b,c,d) \
81 (((uint32_t) d << 24) | \
82 ((uint32_t) c << 16) | \
83 ((uint32_t) b << 8) | \
84 ((uint32_t) a))
85 #else
86 #define MAKE_TAG(a,b,c,d) \
87 (((uint32_t) a << 24) | \
88 ((uint32_t) b << 16) | \
89 ((uint32_t) c << 8) | \
90 ((uint32_t) d))
91 #endif
92
93 typedef enum SkBlobTag {
94 SK_BLOB_TAG_IDENTIFY = MAKE_TAG('I', 'D', 'F', 'Y'),
95 SK_BLOB_TAG_SMART_STATUS = MAKE_TAG('S', 'M', 'S', 'T'),
96 SK_BLOB_TAG_SMART_DATA = MAKE_TAG('S', 'M', 'D', 'T'),
97 SK_BLOB_TAG_SMART_THRESHOLDS = MAKE_TAG('S', 'M', 'T', 'H')
98 } SkBlobTag;
99
100 struct SkDisk {
101 char *name;
102 int fd;
103 SkDiskType type;
104
105 uint64_t size;
106
107 uint8_t identify[512];
108 uint8_t smart_data[512];
109 uint8_t smart_thresholds[512];
110
111 SkBool smart_initialized:1;
112
113 SkBool identify_valid:1;
114 SkBool smart_data_valid:1;
115 SkBool smart_thresholds_valid:1;
116
117 SkBool blob_smart_status:1;
118 SkBool blob_smart_status_valid:1;
119
120 SkBool attribute_verification_bad:1;
121
122 SkIdentifyParsedData identify_parsed_data;
123 SkSmartParsedData smart_parsed_data;
124
125 /* cache for commonly used attributes */
126 SkBool attribute_cache_valid:1;
127 SkBool bad_attribute_now:1;
128 SkBool bad_attribute_in_the_past:1;
129 SkBool reallocated_sector_count_found:1;
130 SkBool current_pending_sector_found:1;
131 uint64_t reallocated_sector_count;
132 uint64_t current_pending_sector;
133
134 void *blob;
135 };
136
137 /* ATA commands */
138 typedef enum SkAtaCommand {
139 SK_ATA_COMMAND_IDENTIFY_DEVICE = 0xEC,
140 SK_ATA_COMMAND_IDENTIFY_PACKET_DEVICE = 0xA1,
141 SK_ATA_COMMAND_SMART = 0xB0,
142 SK_ATA_COMMAND_CHECK_POWER_MODE = 0xE5
143 } SkAtaCommand;
144
145 /* ATA SMART subcommands (ATA8 7.52.1) */
146 typedef enum SkSmartCommand {
147 SK_SMART_COMMAND_READ_DATA = 0xD0,
148 SK_SMART_COMMAND_READ_THRESHOLDS = 0xD1,
149 SK_SMART_COMMAND_EXECUTE_OFFLINE_IMMEDIATE = 0xD4,
150 SK_SMART_COMMAND_ENABLE_OPERATIONS = 0xD8,
151 SK_SMART_COMMAND_DISABLE_OPERATIONS = 0xD9,
152 SK_SMART_COMMAND_RETURN_STATUS = 0xDA
153 } SkSmartCommand;
154
155 /* Hmm, if the data we parse is out of a certain range just consider it misparsed */
156 #define SK_MKELVIN_VALID_MIN ((uint64_t) ((-15LL*1000LL) + 273150LL))
157 #define SK_MKELVIN_VALID_MAX ((uint64_t) ((100LL*1000LL) + 273150LL))
158
159 #define SK_MSECOND_VALID_MIN 1ULL
160 #define SK_MSECOND_VALID_SHORT_MAX (60ULL * 60ULL * 1000ULL)
161 #define SK_MSECOND_VALID_LONG_MAX (30ULL * 365ULL * 24ULL * 60ULL * 60ULL * 1000ULL)
162
163 static int init_smart(SkDisk *d);
164
165 static const char *disk_type_to_human_string(SkDiskType type) {
166
167 /* %STRINGPOOLSTART% */
168 static const char* const map[_SK_DISK_TYPE_MAX] = {
169 [SK_DISK_TYPE_ATA_PASSTHROUGH_16] = "16 Byte SCSI ATA SAT Passthru",
170 [SK_DISK_TYPE_ATA_PASSTHROUGH_12] = "12 Byte SCSI ATA SAT Passthru",
171 [SK_DISK_TYPE_LINUX_IDE] = "Native Linux IDE",
172 [SK_DISK_TYPE_SUNPLUS] = "Sunplus SCSI ATA Passthru",
173 [SK_DISK_TYPE_JMICRON] = "JMicron SCSI ATA Passthru",
174 [SK_DISK_TYPE_BLOB] = "Blob",
175 [SK_DISK_TYPE_AUTO] = "Automatic",
176 [SK_DISK_TYPE_NONE] = "None"
177 };
178 /* %STRINGPOOLSTOP% */
179
180 if (type >= _SK_DISK_TYPE_MAX)
181 return NULL;
182
183 return _P(map[type]);
184 }
185
186 static const char *disk_type_to_prefix_string(SkDiskType type) {
187
188 /* %STRINGPOOLSTART% */
189 static const char* const map[_SK_DISK_TYPE_MAX] = {
190 [SK_DISK_TYPE_ATA_PASSTHROUGH_16] = "sat16",
191 [SK_DISK_TYPE_ATA_PASSTHROUGH_12] = "sat12",
192 [SK_DISK_TYPE_LINUX_IDE] = "linux-ide",
193 [SK_DISK_TYPE_SUNPLUS] = "sunplus",
194 [SK_DISK_TYPE_JMICRON] = "jmicron",
195 [SK_DISK_TYPE_NONE] = "none",
196 [SK_DISK_TYPE_AUTO] = "auto",
197 };
198 /* %STRINGPOOLSTOP% */
199
200 if (type >= _SK_DISK_TYPE_MAX)
201 return NULL;
202
203 return _P(map[type]);
204 }
205
206 static const char *disk_type_from_string(const char *s, SkDiskType *type) {
207 unsigned u;
208
209 assert(s);
210 assert(type);
211
212 for (u = 0; u < _SK_DISK_TYPE_MAX; u++) {
213 const char *t;
214 size_t l;
215
216 if (!(t = disk_type_to_prefix_string(u)))
217 continue;
218
219 l = strlen(t);
220
221 if (strncmp(s, t, l))
222 continue;
223
224 if (s[l] != ':')
225 continue;
226
227 *type = u;
228
229 return s + l + 1;
230 }
231
232 return NULL;
233 }
234
235 static SkBool disk_smart_is_available(SkDisk *d) {
236 return d->identify_valid && !!(d->identify[164] & 1);
237 }
238
239 static SkBool disk_smart_is_enabled(SkDisk *d) {
240 return d->identify_valid && !!(d->identify[170] & 1);
241 }
242
243 static SkBool disk_smart_is_conveyance_test_available(SkDisk *d) {
244 assert(d->smart_data_valid);
245
246 return !!(d->smart_data[367] & 32);
247 }
248 static SkBool disk_smart_is_short_and_extended_test_available(SkDisk *d) {
249 assert(d->smart_data_valid);
250
251 return !!(d->smart_data[367] & 16);
252 }
253
254 static SkBool disk_smart_is_start_test_available(SkDisk *d) {
255 assert(d->smart_data_valid);
256
257 return !!(d->smart_data[367] & 1);
258 }
259
260 static SkBool disk_smart_is_abort_test_available(SkDisk *d) {
261 assert(d->smart_data_valid);
262
263 return !!(d->smart_data[367] & 41);
264 }
265
266 static int disk_linux_ide_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) {
267 uint8_t *bytes = cmd_data;
268 int ret;
269
270 assert(d->type == SK_DISK_TYPE_LINUX_IDE);
271
272 switch (direction) {
273
274 case SK_DIRECTION_OUT:
275
276 /* We could use HDIO_DRIVE_TASKFILE here, but
277 * that's a deprecated ioctl(), hence we don't
278 * do it. And we don't need writing anyway. */
279
280 errno = ENOTSUP;
281 return -1;
282
283 case SK_DIRECTION_IN: {
284 uint8_t *ioctl_data;
285
286 /* We have HDIO_DRIVE_CMD which can only read, but not write,
287 * and cannot do LBA. We use it for all read commands. */
288
289 ioctl_data = alloca(4 + *len);
290 memset(ioctl_data, 0, 4 + *len);
291
292 ioctl_data[0] = (uint8_t) command; /* COMMAND */
293 ioctl_data[1] = ioctl_data[0] == WIN_SMART ? bytes[9] : bytes[3]; /* SECTOR/NSECTOR */
294 ioctl_data[2] = bytes[1]; /* FEATURE */
295 ioctl_data[3] = bytes[3]; /* NSECTOR */
296
297 if ((ret = ioctl(d->fd, HDIO_DRIVE_CMD, ioctl_data)) < 0)
298 return ret;
299
300 memset(bytes, 0, 12);
301 bytes[11] = ioctl_data[0];
302 bytes[1] = ioctl_data[1];
303 bytes[3] = ioctl_data[2];
304
305 memcpy(data, ioctl_data+4, *len);
306
307 return ret;
308 }
309
310 case SK_DIRECTION_NONE: {
311 uint8_t ioctl_data[7];
312
313 /* We have HDIO_DRIVE_TASK which can neither read nor
314 * write, but can do LBA. We use it for all commands that
315 * do neither read nor write */
316
317 memset(ioctl_data, 0, sizeof(ioctl_data));
318
319 ioctl_data[0] = (uint8_t) command; /* COMMAND */
320 ioctl_data[1] = bytes[1]; /* FEATURE */
321 ioctl_data[2] = bytes[3]; /* NSECTOR */
322
323 ioctl_data[3] = bytes[9]; /* LBA LOW */
324 ioctl_data[4] = bytes[8]; /* LBA MID */
325 ioctl_data[5] = bytes[7]; /* LBA HIGH */
326 ioctl_data[6] = bytes[10]; /* SELECT */
327
328 if ((ret = ioctl(d->fd, HDIO_DRIVE_TASK, ioctl_data)))
329 return ret;
330
331 memset(bytes, 0, 12);
332 bytes[11] = ioctl_data[0];
333 bytes[1] = ioctl_data[1];
334 bytes[3] = ioctl_data[2];
335
336 bytes[9] = ioctl_data[3];
337 bytes[8] = ioctl_data[4];
338 bytes[7] = ioctl_data[5];
339
340 bytes[10] = ioctl_data[6];
341
342 return ret;
343 }
344
345 default:
346 assert(FALSE);
347 return -1;
348 }
349 }
350
351 /* Sends a SCSI command block */
352 static int sg_io(int fd, int direction,
353 const void *cdb, size_t cdb_len,
354 void *data, size_t data_len,
355 void *sense, size_t sense_len) {
356
357 struct sg_io_hdr io_hdr;
358
359 memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
360
361 io_hdr.interface_id = 'S';
362 io_hdr.cmdp = (unsigned char*) cdb;
363 io_hdr.cmd_len = cdb_len;
364 io_hdr.dxferp = data;
365 io_hdr.dxfer_len = data_len;
366 io_hdr.sbp = sense;
367 io_hdr.mx_sb_len = sense_len;
368 io_hdr.dxfer_direction = direction;
369 io_hdr.timeout = SK_TIMEOUT;
370
371 return ioctl(fd, SG_IO, &io_hdr);
372 }
373
374 static int disk_passthrough_16_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) {
375 uint8_t *bytes = cmd_data;
376 uint8_t cdb[16];
377 uint8_t sense[32];
378 uint8_t *desc = sense+8;
379 int ret;
380
381 static const int direction_map[] = {
382 [SK_DIRECTION_NONE] = SG_DXFER_NONE,
383 [SK_DIRECTION_IN] = SG_DXFER_FROM_DEV,
384 [SK_DIRECTION_OUT] = SG_DXFER_TO_DEV
385 };
386
387 assert(d->type == SK_DISK_TYPE_ATA_PASSTHROUGH_16);
388
389 /* ATA Pass-Through 16 byte command, as described in "T10 04-262r8
390 * ATA Command Pass-Through":
391 * http://www.t10.org/ftp/t10/document.04/04-262r8.pdf */
392
393 memset(cdb, 0, sizeof(cdb));
394
395 cdb[0] = 0x85; /* OPERATION CODE: 16 byte pass through */
396
397 if (direction == SK_DIRECTION_NONE) {
398 cdb[1] = 3 << 1; /* PROTOCOL: Non-Data */
399 cdb[2] = 0x20; /* OFF_LINE=0, CK_COND=1, T_DIR=0, BYT_BLOK=0, T_LENGTH=0 */
400
401 } else if (direction == SK_DIRECTION_IN) {
402 cdb[1] = 4 << 1; /* PROTOCOL: PIO Data-in */
403 cdb[2] = 0x2e; /* OFF_LINE=0, CK_COND=1, T_DIR=1, BYT_BLOK=1, T_LENGTH=2 */
404
405 } else if (direction == SK_DIRECTION_OUT) {
406 cdb[1] = 5 << 1; /* PROTOCOL: PIO Data-Out */
407 cdb[2] = 0x26; /* OFF_LINE=0, CK_COND=1, T_DIR=0, BYT_BLOK=1, T_LENGTH=2 */
408 }
409
410 cdb[3] = bytes[0]; /* FEATURES */
411 cdb[4] = bytes[1];
412
413 cdb[5] = bytes[2]; /* SECTORS */
414 cdb[6] = bytes[3];
415
416 cdb[8] = bytes[9]; /* LBA LOW */
417 cdb[10] = bytes[8]; /* LBA MID */
418 cdb[12] = bytes[7]; /* LBA HIGH */
419
420 cdb[13] = bytes[10] & 0x4F; /* SELECT */
421 cdb[14] = (uint8_t) command;
422
423 memset(sense, 0, sizeof(sense));
424
425 if ((ret = sg_io(d->fd, direction_map[direction], cdb, sizeof(cdb), data, len ? *len : 0, sense, sizeof(sense))) < 0)
426 return ret;
427
428 if (sense[0] != 0x72 || desc[0] != 0x9 || desc[1] != 0x0c) {
429 errno = EIO;
430 return -1;
431 }
432
433 memset(bytes, 0, 12);
434
435 bytes[1] = desc[3];
436 bytes[2] = desc[4];
437 bytes[3] = desc[5];
438 bytes[9] = desc[7];
439 bytes[8] = desc[9];
440 bytes[7] = desc[11];
441 bytes[10] = desc[12];
442 bytes[11] = desc[13];
443
444 return ret;
445 }
446
447 static int disk_passthrough_12_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) {
448 uint8_t *bytes = cmd_data;
449 uint8_t cdb[12];
450 uint8_t sense[32];
451 uint8_t *desc = sense+8;
452 int ret;
453
454 static const int direction_map[] = {
455 [SK_DIRECTION_NONE] = SG_DXFER_NONE,
456 [SK_DIRECTION_IN] = SG_DXFER_FROM_DEV,
457 [SK_DIRECTION_OUT] = SG_DXFER_TO_DEV
458 };
459
460 assert(d->type == SK_DISK_TYPE_ATA_PASSTHROUGH_12);
461
462 /* ATA Pass-Through 12 byte command, as described in "T10 04-262r8
463 * ATA Command Pass-Through":
464 * http://www.t10.org/ftp/t10/document.04/04-262r8.pdf */
465
466 memset(cdb, 0, sizeof(cdb));
467
468 cdb[0] = 0xa1; /* OPERATION CODE: 12 byte pass through */
469
470 if (direction == SK_DIRECTION_NONE) {
471 cdb[1] = 3 << 1; /* PROTOCOL: Non-Data */
472 cdb[2] = 0x20; /* OFF_LINE=0, CK_COND=1, T_DIR=0, BYT_BLOK=0, T_LENGTH=0 */
473
474 } else if (direction == SK_DIRECTION_IN) {
475 cdb[1] = 4 << 1; /* PROTOCOL: PIO Data-in */
476 cdb[2] = 0x2e; /* OFF_LINE=0, CK_COND=1, T_DIR=1, BYT_BLOK=1, T_LENGTH=2 */
477
478 } else if (direction == SK_DIRECTION_OUT) {
479 cdb[1] = 5 << 1; /* PROTOCOL: PIO Data-Out */
480 cdb[2] = 0x26; /* OFF_LINE=0, CK_COND=1, T_DIR=0, BYT_BLOK=1, T_LENGTH=2 */
481 }
482
483 cdb[3] = bytes[1]; /* FEATURES */
484 cdb[4] = bytes[3]; /* SECTORS */
485
486 cdb[5] = bytes[9]; /* LBA LOW */
487 cdb[6] = bytes[8]; /* LBA MID */
488 cdb[7] = bytes[7]; /* LBA HIGH */
489
490 cdb[8] = bytes[10] & 0x4F; /* SELECT */
491 cdb[9] = (uint8_t) command;
492
493 memset(sense, 0, sizeof(sense));
494
495 if ((ret = sg_io(d->fd, direction_map[direction], cdb, sizeof(cdb), data, len ? *len : 0, sense, sizeof(sense))) < 0)
496 return ret;
497
498 if (sense[0] != 0x72 || desc[0] != 0x9 || desc[1] != 0x0c) {
499 errno = EIO;
500 return -1;
501 }
502
503 memset(bytes, 0, 12);
504
505 bytes[1] = desc[3]; /* FEATURES */
506 bytes[2] = desc[4]; /* STATUS */
507 bytes[3] = desc[5]; /* SECTORS */
508 bytes[9] = desc[7]; /* LBA LOW */
509 bytes[8] = desc[9]; /* LBA MID */
510 bytes[7] = desc[11]; /* LBA HIGH */
511 bytes[10] = desc[12]; /* SELECT */
512 bytes[11] = desc[13]; /* ERROR */
513
514 return ret;
515 }
516
517 static int disk_sunplus_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) {
518 uint8_t *bytes = cmd_data;
519 uint8_t cdb[12];
520 uint8_t sense[32], buf[8];
521 int ret;
522 static const int direction_map[] = {
523 [SK_DIRECTION_NONE] = SG_DXFER_NONE,
524 [SK_DIRECTION_IN] = SG_DXFER_FROM_DEV,
525 [SK_DIRECTION_OUT] = SG_DXFER_TO_DEV
526 };
527
528 assert(d->type == SK_DISK_TYPE_SUNPLUS);
529
530 /* SunplusIT specific SCSI ATA pass-thru. Inspired by smartmonutils' support for these bridges */
531
532 memset(cdb, 0, sizeof(cdb));
533
534 cdb[0] = 0xF8; /* OPERATION CODE: Sunplus specific */
535 cdb[1] = 0x00; /* Subcommand: Pass-thru */
536 cdb[2] = 0x22;
537
538 if (direction == SK_DIRECTION_NONE)
539 cdb[3] = 0x00; /* protocol */
540 else if (direction == SK_DIRECTION_IN)
541 cdb[3] = 0x10; /* protocol */
542 else if (direction == SK_DIRECTION_OUT)
543 cdb[3] = 0x11; /* protocol */
544
545 cdb[4] = bytes[3]; /* size? */
546 cdb[5] = bytes[1]; /* FEATURES */
547 cdb[6] = bytes[3]; /* SECTORS */
548 cdb[7] = bytes[9]; /* LBA LOW */
549 cdb[8] = bytes[8]; /* LBA MID */
550 cdb[9] = bytes[7]; /* LBA HIGH */
551 cdb[10] = bytes[10] | 0xA0; /* SELECT */
552 cdb[11] = (uint8_t) command;
553
554 memset(sense, 0, sizeof(sense));
555
556 /* Issue request */
557 if ((ret = sg_io(d->fd, direction_map[direction], cdb, sizeof(cdb), data, len ? *len : 0, sense, sizeof(sense))) < 0)
558 return ret;
559
560 memset(cdb, 0, sizeof(cdb));
561
562 cdb[0] = 0xF8;
563 cdb[1] = 0x00;
564 cdb[2] = 0x21;
565
566 memset(buf, 0, sizeof(buf));
567
568 /* Ask for response */
569 if ((ret = sg_io(d->fd, SG_DXFER_FROM_DEV, cdb, sizeof(cdb), buf, sizeof(buf), sense, sizeof(sense))) < 0)
570 return ret;
571
572 memset(bytes, 0, 12);
573
574 bytes[2] = buf[1]; /* ERROR */
575 bytes[3] = buf[2]; /* SECTORS */
576 bytes[9] = buf[3]; /* LBA LOW */
577 bytes[8] = buf[4]; /* LBA MID */
578 bytes[7] = buf[5]; /* LBA HIGH */
579 bytes[10] = buf[6]; /* SELECT */
580 bytes[11] = buf[7]; /* STATUS */
581
582 return ret;
583 }
584
585 static int disk_jmicron_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* _data, size_t *_len) {
586 uint8_t *bytes = cmd_data;
587 uint8_t cdb[12];
588 uint8_t sense[32];
589 uint8_t port;
590 int ret;
591 SkBool is_smart_status = FALSE;
592 void *data = _data;
593 size_t len = _len ? *_len : 0;
594 uint8_t smart_status = 0;
595
596 static const int direction_map[] = {
597 [SK_DIRECTION_NONE] = SG_DXFER_NONE,
598 [SK_DIRECTION_IN] = SG_DXFER_FROM_DEV,
599 [SK_DIRECTION_OUT] = SG_DXFER_TO_DEV
600 };
601
602 assert(d->type == SK_DISK_TYPE_JMICRON);
603
604 /* JMicron specific SCSI ATA pass-thru. Inspired by smartmonutils' support for these bridges */
605
606 memset(cdb, 0, sizeof(cdb));
607
608 cdb[0] = 0xdf; /* operation code */
609 cdb[1] = 0x10;
610 cdb[2] = 0x00;
611 cdb[3] = 0x00; /* size HI */
612 cdb[4] = sizeof(port); /* size LO */
613 cdb[5] = 0x00;
614 cdb[6] = 0x72; /* register address HI */
615 cdb[7] = 0x0f; /* register address LO */
616 cdb[8] = 0x00;
617 cdb[9] = 0x00;
618 cdb[10] = 0x00;
619 cdb[11] = 0xfd;
620
621 memset(sense, 0, sizeof(sense));
622
623 if ((ret = sg_io(d->fd, SG_DXFER_FROM_DEV, cdb, sizeof(cdb), &port, sizeof(port), sense, sizeof(sense))) < 0)
624 return ret;
625
626 /* Port & 0x04 is port #0, Port & 0x40 is port #1 */
627 if (!(port & 0x44))
628 return -EIO;
629
630 cdb[0] = 0xdf; /* OPERATION CODE: 12 byte pass through */
631
632 if (command == SK_ATA_COMMAND_SMART && bytes[1] == SK_SMART_COMMAND_RETURN_STATUS) {
633 /* We need to rewrite the SMART status request */
634 is_smart_status = TRUE;
635 direction = SK_DIRECTION_IN;
636 data = &smart_status;
637 len = sizeof(smart_status);
638 cdb[1] = 0x10;
639 } else if (direction == SK_DIRECTION_NONE)
640 cdb[1] = 0x10;
641 else if (direction == SK_DIRECTION_IN)
642 cdb[1] = 0x10;
643 else if (direction == SK_DIRECTION_OUT)
644 cdb[1] = 0x00;
645
646 cdb[2] = 0x00;
647
648 cdb[3] = (uint8_t) (len >> 8);
649 cdb[4] = (uint8_t) (len & 0xFF);
650
651 cdb[5] = bytes[1]; /* FEATURES */
652 cdb[6] = bytes[3]; /* SECTORS */
653
654 cdb[7] = bytes[9]; /* LBA LOW */
655 cdb[8] = bytes[8]; /* LBA MID */
656 cdb[9] = bytes[7]; /* LBA HIGH */
657
658 cdb[10] = bytes[10] | ((port & 0x04) ? 0xA0 : 0xB0); /* SELECT */
659 cdb[11] = (uint8_t) command;
660
661 memset(sense, 0, sizeof(sense));
662
663 if ((ret = sg_io(d->fd, direction_map[direction], cdb, sizeof(cdb), data, len, sense, sizeof(sense))) < 0)
664 return ret;
665
666 memset(bytes, 0, 12);
667
668 if (is_smart_status) {
669 if (smart_status == 0x01 || smart_status == 0xc2) {
670 bytes[7] = 0xc2; /* LBA HIGH */
671 bytes[8] = 0x4f; /* LBA MID */
672 } else if (smart_status == 0x00 || smart_status == 0x2c) {
673 bytes[7] = 0x2c; /* LBA HIGH */
674 bytes[8] = 0xf4; /* LBA MID */
675 } else
676 return -EIO;
677 } else {
678 uint8_t regbuf[16];
679
680 cdb[0] = 0xdf; /* operation code */
681 cdb[1] = 0x10;
682 cdb[2] = 0x00;
683 cdb[3] = 0x00; /* size HI */
684 cdb[4] = sizeof(regbuf); /* size LO */
685 cdb[5] = 0x00;
686 cdb[6] = (port & 0x04) ? 0x80 : 0x90; /* register address HI */
687 cdb[7] = 0x00; /* register address LO */
688 cdb[8] = 0x00;
689 cdb[9] = 0x00;
690 cdb[10] = 0x00;
691 cdb[11] = 0xfd;
692
693 if ((ret = sg_io(d->fd, SG_DXFER_FROM_DEV, cdb, sizeof(cdb), regbuf, sizeof(regbuf), sense, sizeof(sense))) < 0)
694 return ret;
695
696 bytes[2] = regbuf[14]; /* STATUS */
697 bytes[3] = regbuf[0]; /* SECTORS */
698 bytes[9] = regbuf[6]; /* LBA LOW */
699 bytes[8] = regbuf[4]; /* LBA MID */
700 bytes[7] = regbuf[10]; /* LBA HIGH */
701 bytes[10] = regbuf[9]; /* SELECT */
702 bytes[11] = regbuf[13]; /* ERROR */
703 }
704
705 return ret;
706 }
707
708 static int disk_command(SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) {
709
710 static int (* const disk_command_table[_SK_DISK_TYPE_MAX]) (SkDisk *d, SkAtaCommand command, SkDirection direction, void* cmd_data, void* data, size_t *len) = {
711 [SK_DISK_TYPE_LINUX_IDE] = disk_linux_ide_command,
712 [SK_DISK_TYPE_ATA_PASSTHROUGH_12] = disk_passthrough_12_command,
713 [SK_DISK_TYPE_ATA_PASSTHROUGH_16] = disk_passthrough_16_command,
714 [SK_DISK_TYPE_SUNPLUS] = disk_sunplus_command,
715 [SK_DISK_TYPE_JMICRON] = disk_jmicron_command,
716 [SK_DISK_TYPE_BLOB] = NULL,
717 [SK_DISK_TYPE_AUTO] = NULL,
718 [SK_DISK_TYPE_NONE] = NULL
719 };
720
721 assert(d);
722 assert(d->type <= _SK_DISK_TYPE_MAX);
723 assert(direction <= _SK_DIRECTION_MAX);
724
725 assert(direction == SK_DIRECTION_NONE || (data && len && *len > 0));
726 assert(direction != SK_DIRECTION_NONE || (!data && !len));
727
728 if (!disk_command_table[d->type]) {
729 errno = -ENOTSUP;
730 return -1;
731 }
732
733 return disk_command_table[d->type](d, command, direction, cmd_data, data, len);
734 }
735
736 static int disk_identify_device(SkDisk *d) {
737 uint16_t cmd[6];
738 int ret;
739 size_t len = 512;
740 const uint8_t *p;
741
742 if (d->type == SK_DISK_TYPE_BLOB)
743 return 0;
744
745 memset(d->identify, 0, len);
746 memset(cmd, 0, sizeof(cmd));
747
748 cmd[1] = htons(1);
749
750 if ((ret = disk_command(d, SK_ATA_COMMAND_IDENTIFY_DEVICE, SK_DIRECTION_IN, cmd, d->identify, &len)) < 0)
751 return ret;
752
753 if (len != 512) {
754 errno = EIO;
755 return -1;
756 }
757
758 /* Check if IDENTIFY data is all NULs */
759 for (p = d->identify; p < (const uint8_t*) d->identify+len; p++)
760 if (*p) {
761 p = NULL;
762 break;
763 }
764
765 if (p) {
766 errno = EIO;
767 return -1;
768 }
769
770 d->identify_valid = TRUE;
771
772 return 0;
773 }
774
775 int sk_disk_check_sleep_mode(SkDisk *d, SkBool *awake) {
776 int ret;
777 uint16_t cmd[6];
778 uint8_t status;
779
780 if (!d->identify_valid) {
781 errno = ENOTSUP;
782 return -1;
783 }
784
785 if (d->type == SK_DISK_TYPE_BLOB) {
786 errno = ENOTSUP;
787 return -1;
788 }
789
790 memset(cmd, 0, sizeof(cmd));
791
792 if ((ret = disk_command(d, SK_ATA_COMMAND_CHECK_POWER_MODE, SK_DIRECTION_NONE, cmd, NULL, 0)) < 0)
793 return ret;
794
795 if (cmd[0] != 0 || (ntohs(cmd[5]) & 1) != 0) {
796 errno = EIO;
797 return -1;
798 }
799
800 status = ntohs(cmd[1]) & 0xFF;
801 *awake = status == 0xFF || status == 0x80; /* idle and active/idle is considered awake */
802
803 return 0;
804 }
805
806 static int disk_smart_enable(SkDisk *d, SkBool b) {
807 uint16_t cmd[6];
808
809 if (!disk_smart_is_available(d)) {
810 errno = ENOTSUP;
811 return -1;
812 }
813
814 if (d->type == SK_DISK_TYPE_BLOB) {
815 errno = ENOTSUP;
816 return -1;
817 }
818
819 memset(cmd, 0, sizeof(cmd));
820
821 cmd[0] = htons(b ? SK_SMART_COMMAND_ENABLE_OPERATIONS : SK_SMART_COMMAND_DISABLE_OPERATIONS);
822 cmd[2] = htons(0x0000U);
823 cmd[3] = htons(0x00C2U);
824 cmd[4] = htons(0x4F00U);
825
826 return disk_command(d, SK_ATA_COMMAND_SMART, SK_DIRECTION_NONE, cmd, NULL, 0);
827 }
828
829 int sk_disk_smart_read_data(SkDisk *d) {
830 uint16_t cmd[6];
831 int ret;
832 size_t len = 512;
833
834 if (init_smart(d) < 0)
835 return -1;
836
837 if (!disk_smart_is_available(d)) {
838 errno = ENOTSUP;
839 return -1;
840 }
841
842 if (d->type == SK_DISK_TYPE_BLOB)
843 return 0;
844
845 memset(cmd, 0, sizeof(cmd));
846
847 cmd[0] = htons(SK_SMART_COMMAND_READ_DATA);
848 cmd[1] = htons(1);
849 cmd[2] = htons(0x0000U);
850 cmd[3] = htons(0x00C2U);
851 cmd[4] = htons(0x4F00U);
852
853 if ((ret = disk_command(d, SK_ATA_COMMAND_SMART, SK_DIRECTION_IN, cmd, d->smart_data, &len)) < 0)
854 return ret;
855
856 d->smart_data_valid = TRUE;
857
858 return ret;
859 }
860
861 static int disk_smart_read_thresholds(SkDisk *d) {
862 uint16_t cmd[6];
863 int ret;
864 size_t len = 512;
865
866 if (!disk_smart_is_available(d)) {
867 errno = ENOTSUP;
868 return -1;
869 }
870
871 if (d->type == SK_DISK_TYPE_BLOB)
872 return 0;
873
874 memset(cmd, 0, sizeof(cmd));
875
876 cmd[0] = htons(SK_SMART_COMMAND_READ_THRESHOLDS);
877 cmd[1] = htons(1);
878 cmd[2] = htons(0x0000U);
879 cmd[3] = htons(0x00C2U);
880 cmd[4] = htons(0x4F00U);
881
882 if ((ret = disk_command(d, SK_ATA_COMMAND_SMART, SK_DIRECTION_IN, cmd, d->smart_thresholds, &len)) < 0)
883 return ret;
884
885 d->smart_thresholds_valid = TRUE;
886
887 return ret;
888 }
889
890 int sk_disk_smart_status(SkDisk *d, SkBool *good) {
891 uint16_t cmd[6];
892 int ret;
893
894 if (init_smart(d) < 0)
895 return -1;
896
897 if (!disk_smart_is_available(d)) {
898 errno = ENOTSUP;
899 return -1;
900 }
901
902 if (d->type == SK_DISK_TYPE_BLOB) {
903
904 if (d->blob_smart_status_valid) {
905 *good = d->blob_smart_status;
906 return 0;
907 }
908
909 errno = ENXIO;
910 return -1;
911 }
912
913 memset(cmd, 0, sizeof(cmd));
914
915 cmd[0] = htons(SK_SMART_COMMAND_RETURN_STATUS);
916 cmd[1] = htons(0x0000U);
917 cmd[3] = htons(0x00C2U);
918 cmd[4] = htons(0x4F00U);
919
920 if ((ret = disk_command(d, SK_ATA_COMMAND_SMART, SK_DIRECTION_NONE, cmd, NULL, 0)) < 0)
921 return ret;
922
923 /* SAT/USB bridges truncate packets, so we only check for 4F,
924 * not for 2C on those */
925 if ((d->type == SK_DISK_TYPE_ATA_PASSTHROUGH_12 || cmd[3] == htons(0x00C2U)) &&
926 cmd[4] == htons(0x4F00U))
927 *good = TRUE;
928 else if ((d->type == SK_DISK_TYPE_ATA_PASSTHROUGH_12 || cmd[3] == htons(0x002CU)) &&
929 cmd[4] == htons(0xF400U))
930 *good = FALSE;
931 else {
932 errno = EIO;
933 return -1;
934 }
935
936 return ret;
937 }
938
939 int sk_disk_smart_self_test(SkDisk *d, SkSmartSelfTest test) {
940 uint16_t cmd[6];
941 int ret;
942
943 if (init_smart(d) < 0)
944 return -1;
945
946 if (!disk_smart_is_available(d)) {
947 errno = ENOTSUP;
948 return -1;
949 }
950
951 if (d->type == SK_DISK_TYPE_BLOB) {
952 errno = ENOTSUP;
953 return -1;
954 }
955
956 if (!d->smart_data_valid)
957 if ((ret = sk_disk_smart_read_data(d)) < 0)
958 return -1;
959
960 assert(d->smart_data_valid);
961
962 if (test != SK_SMART_SELF_TEST_SHORT &&
963 test != SK_SMART_SELF_TEST_EXTENDED &&
964 test != SK_SMART_SELF_TEST_CONVEYANCE &&
965 test != SK_SMART_SELF_TEST_ABORT) {
966 errno = EINVAL;
967 return -1;
968 }
969
970 if (!disk_smart_is_start_test_available(d)
971 || (test == SK_SMART_SELF_TEST_ABORT && !disk_smart_is_abort_test_available(d))
972 || ((test == SK_SMART_SELF_TEST_SHORT || test == SK_SMART_SELF_TEST_EXTENDED) && !disk_smart_is_short_and_extended_test_available(d))
973 || (test == SK_SMART_SELF_TEST_CONVEYANCE && !disk_smart_is_conveyance_test_available(d))) {
974 errno = ENOTSUP;
975 return -1;
976 }
977
978 if (test == SK_SMART_SELF_TEST_ABORT &&
979 !disk_smart_is_abort_test_available(d)) {
980 errno = ENOTSUP;
981 return -1;
982 }
983
984 memset(cmd, 0, sizeof(cmd));
985
986 cmd[0] = htons(SK_SMART_COMMAND_EXECUTE_OFFLINE_IMMEDIATE);
987 cmd[2] = htons(0x0000U);
988 cmd[3] = htons(0x00C2U);
989 cmd[4] = htons(0x4F00U | (uint16_t) test);
990
991 return disk_command(d, SK_ATA_COMMAND_SMART, SK_DIRECTION_NONE, cmd, NULL, NULL);
992 }
993
994 static void swap_strings(char *s, size_t len) {
995 assert((len & 1) == 0);
996
997 for (; len > 0; s += 2, len -= 2) {
998 char t;
999 t = s[0];
1000 s[0] = s[1];
1001 s[1] = t;
1002 }
1003 }
1004
1005 static void clean_strings(char *s) {
1006 char *e;
1007
1008 for (e = s; *e; e++)
1009 if (*e < ' ' || *e >= 127)
1010 *e = ' ';
1011 }
1012
1013 static void drop_spaces(char *s) {
1014 char *d = s;
1015 SkBool prev_space = FALSE;
1016
1017 s += strspn(s, " ");
1018
1019 for (;*s; s++) {
1020
1021 if (prev_space) {
1022 if (*s != ' ') {
1023 prev_space = FALSE;
1024 *(d++) = ' ';
1025 *(d++) = *s;
1026 }
1027 } else {
1028 if (*s == ' ')
1029 prev_space = TRUE;
1030 else
1031 *(d++) = *s;
1032 }
1033 }
1034
1035 *d = 0;
1036 }
1037
1038 static void read_string(char *d, uint8_t *s, size_t len) {
1039 memcpy(d, s, len);
1040 d[len] = 0;
1041 swap_strings(d, len);
1042 clean_strings(d);
1043 drop_spaces(d);
1044 }
1045
1046 int sk_disk_identify_parse(SkDisk *d, const SkIdentifyParsedData **ipd) {
1047 assert(d);
1048 assert(ipd);
1049
1050 if (!d->identify_valid) {
1051 errno = ENOENT;
1052 return -1;
1053 }
1054
1055 read_string(d->identify_parsed_data.serial, d->identify+20, 20);
1056 read_string(d->identify_parsed_data.firmware, d->identify+46, 8);
1057 read_string(d->identify_parsed_data.model, d->identify+54, 40);
1058
1059 *ipd = &d->identify_parsed_data;
1060
1061 return 0;
1062 }
1063
1064 int sk_disk_smart_is_available(SkDisk *d, SkBool *b) {
1065 assert(d);
1066 assert(b);
1067
1068 if (!d->identify_valid) {
1069 errno = ENOTSUP;
1070 return -1;
1071 }
1072
1073 *b = disk_smart_is_available(d);
1074 return 0;
1075 }
1076
1077 int sk_disk_identify_is_available(SkDisk *d, SkBool *b) {
1078 assert(d);
1079 assert(b);
1080
1081 *b = d->identify_valid;
1082 return 0;
1083 }
1084
1085 const char *sk_smart_offline_data_collection_status_to_string(SkSmartOfflineDataCollectionStatus status) {
1086
1087 /* %STRINGPOOLSTART% */
1088 static const char* const map[] = {
1089 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_NEVER] = "Off-line data collection activity was never started.",
1090 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_SUCCESS] = "Off-line data collection activity was completed without error.",
1091 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_INPROGRESS] = "Off-line activity in progress.",
1092 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_SUSPENDED] = "Off-line data collection activity was suspended by an interrupting command from host.",
1093 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_ABORTED] = "Off-line data collection activity was aborted by an interrupting command from host.",
1094 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_FATAL] = "Off-line data collection activity was aborted by the device with a fatal error.",
1095 [SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_UNKNOWN] = "Unknown status"
1096 };
1097 /* %STRINGPOOLSTOP% */
1098
1099 if (status >= _SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_MAX)
1100 return NULL;
1101
1102 return _P(map[status]);
1103 }
1104
1105 const char *sk_smart_self_test_execution_status_to_string(SkSmartSelfTestExecutionStatus status) {
1106
1107 /* %STRINGPOOLSTART% */
1108 static const char* const map[] = {
1109 [SK_SMART_SELF_TEST_EXECUTION_STATUS_SUCCESS_OR_NEVER] = "The previous self-test routine completed without error or no self-test has ever been run.",
1110 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ABORTED] = "The self-test routine was aborted by the host.",
1111 [SK_SMART_SELF_TEST_EXECUTION_STATUS_INTERRUPTED] = "The self-test routine was interrupted by the host with a hardware or software reset.",
1112 [SK_SMART_SELF_TEST_EXECUTION_STATUS_FATAL] = "A fatal error or unknown test error occurred while the device was executing its self-test routine and the device was unable to complete the self-test routine.",
1113 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ERROR_UNKNOWN] = "The previous self-test completed having a test element that failed and the test element that failed.",
1114 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ERROR_ELECTRICAL] = "The previous self-test completed having the electrical element of the test failed.",
1115 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ERROR_SERVO] = "The previous self-test completed having the servo (and/or seek) test element of the test failed.",
1116 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ERROR_READ] = "The previous self-test completed having the read element of the test failed.",
1117 [SK_SMART_SELF_TEST_EXECUTION_STATUS_ERROR_HANDLING] = "The previous self-test completed having a test element that failed and the device is suspected of having handling damage.",
1118 [SK_SMART_SELF_TEST_EXECUTION_STATUS_INPROGRESS] = "Self-test routine in progress"
1119 };
1120 /* %STRINGPOOLSTOP% */
1121
1122 if (status >= _SK_SMART_SELF_TEST_EXECUTION_STATUS_MAX)
1123 return NULL;
1124
1125 return _P(map[status]);
1126 }
1127
1128 const char* sk_smart_self_test_to_string(SkSmartSelfTest test) {
1129
1130 switch (test) {
1131 case SK_SMART_SELF_TEST_SHORT:
1132 return "short";
1133 case SK_SMART_SELF_TEST_EXTENDED:
1134 return "extended";
1135 case SK_SMART_SELF_TEST_CONVEYANCE:
1136 return "conveyance";
1137 case SK_SMART_SELF_TEST_ABORT:
1138 return "abort";
1139 }
1140
1141 return NULL;
1142 }
1143
1144 SkBool sk_smart_self_test_available(const SkSmartParsedData *d, SkSmartSelfTest test) {
1145 assert(d);
1146
1147 if (!d->start_test_available)
1148 return FALSE;
1149
1150 switch (test) {
1151 case SK_SMART_SELF_TEST_SHORT:
1152 case SK_SMART_SELF_TEST_EXTENDED:
1153 return d->short_and_extended_test_available;
1154 case SK_SMART_SELF_TEST_CONVEYANCE:
1155 return d->conveyance_test_available;
1156 case SK_SMART_SELF_TEST_ABORT:
1157 return d->abort_test_available;
1158 default:
1159 return FALSE;
1160 }
1161 }
1162
1163 unsigned sk_smart_self_test_polling_minutes(const SkSmartParsedData *d, SkSmartSelfTest test) {
1164 assert(d);
1165
1166 if (!sk_smart_self_test_available(d, test))
1167 return 0;
1168
1169 switch (test) {
1170 case SK_SMART_SELF_TEST_SHORT:
1171 return d->short_test_polling_minutes;
1172 case SK_SMART_SELF_TEST_EXTENDED:
1173 return d->extended_test_polling_minutes;
1174 case SK_SMART_SELF_TEST_CONVEYANCE:
1175 return d->conveyance_test_polling_minutes;
1176 default:
1177 return 0;
1178 }
1179 }
1180
1181 static void make_pretty(SkSmartAttributeParsedData *a) {
1182 uint64_t fourtyeight;
1183
1184 if (!a->name)
1185 return;
1186
1187 if (a->pretty_unit == SK_SMART_ATTRIBUTE_UNIT_UNKNOWN)
1188 return;
1189
1190 fourtyeight =
1191 ((uint64_t) a->raw[0]) |
1192 (((uint64_t) a->raw[1]) << 8) |
1193 (((uint64_t) a->raw[2]) << 16) |
1194 (((uint64_t) a->raw[3]) << 24) |
1195 (((uint64_t) a->raw[4]) << 32) |
1196 (((uint64_t) a->raw[5]) << 40);
1197
1198 if (!strcmp(a->name, "spin-up-time"))
1199 a->pretty_value = fourtyeight & 0xFFFF;
1200 else if (!strcmp(a->name, "airflow-temperature-celsius") ||
1201 !strcmp(a->name, "temperature-celsius") ||
1202 !strcmp(a->name, "temperature-celsius-2"))
1203 a->pretty_value = (fourtyeight & 0xFFFF)*1000 + 273150;
1204 else if (!strcmp(a->name, "temperature-centi-celsius"))
1205 a->pretty_value = (fourtyeight & 0xFFFF)*100 + 273150;
1206 else if (!strcmp(a->name, "power-on-minutes"))
1207 a->pretty_value = fourtyeight * 60 * 1000;
1208 else if (!strcmp(a->name, "power-on-seconds") ||
1209 !strcmp(a->name, "power-on-seconds-2"))
1210 a->pretty_value = fourtyeight * 1000;
1211 else if (!strcmp(a->name, "power-on-half-minutes"))
1212 a->pretty_value = fourtyeight * 30 * 1000;
1213 else if (!strcmp(a->name, "power-on-hours") ||
1214 !strcmp(a->name, "loaded-hours") ||
1215 !strcmp(a->name, "head-flying-hours"))
1216 a->pretty_value = (fourtyeight & 0xFFFFFFFFU) * 60 * 60 * 1000;
1217 else if (!strcmp(a->name, "reallocated-sector-count") ||
1218 !strcmp(a->name, "current-pending-sector"))
1219 a->pretty_value = fourtyeight & 0xFFFFFFFFU;
1220 else if (!strcmp(a->name, "endurance-remaining") ||
1221 !strcmp(a->name, "available-reserved-space"))
1222 a->pretty_value = a->current_value;
1223 else if (!strcmp(a->name, "total-lbas-written") ||
1224 !strcmp(a->name, "total-lbas-read"))
1225 a->pretty_value = fourtyeight * 65536LLU * 512LLU / 1000000LLU;
1226 else if (!strcmp(a->name, "timed-workload-media-wear") ||
1227 !strcmp(a->name, "timed-workload-host-reads"))
1228 a->pretty_value = (double)fourtyeight / 1024LLU;
1229 else if (!strcmp(a->name, "workload-timer"))
1230 a->pretty_value = fourtyeight * 60 * 1000;
1231 else
1232 a->pretty_value = fourtyeight;
1233 }
1234
1235 typedef void (*SkSmartAttributeVerify)(SkDisk *d, SkSmartAttributeParsedData *a);
1236
1237 typedef struct SkSmartAttributeInfo {
1238 const char *name;
1239 SkSmartAttributeUnit unit;
1240 SkSmartAttributeVerify verify;
1241 } SkSmartAttributeInfo;
1242
1243 static void verify_temperature(SkDisk *d, SkSmartAttributeParsedData *a) {
1244 assert(a);
1245 assert(a->pretty_unit == SK_SMART_ATTRIBUTE_UNIT_MKELVIN);
1246
1247 if (a->pretty_value < SK_MKELVIN_VALID_MIN ||
1248 a->pretty_value > SK_MKELVIN_VALID_MAX) {
1249 a->pretty_unit = SK_SMART_ATTRIBUTE_UNIT_UNKNOWN;
1250 d->attribute_verification_bad = TRUE;
1251 }
1252 }
1253
1254 static void verify_short_time(SkDisk *d, SkSmartAttributeParsedData *a) {
1255 assert(a);
1256 assert(a->pretty_unit == SK_SMART_ATTRIBUTE_UNIT_MSECONDS);
1257
1258 if (a->pretty_value < SK_MSECOND_VALID_MIN ||
1259 a->pretty_value > SK_MSECOND_VALID_SHORT_MAX) {
1260 a->pretty_unit = SK_SMART_ATTRIBUTE_UNIT_UNKNOWN;
1261 d->attribute_verification_bad = TRUE;
1262 }
1263 }
1264
1265 static void verify_long_time(SkDisk *d, SkSmartAttributeParsedData *a) {
1266 assert(a);
1267 assert(a->pretty_unit == SK_SMART_ATTRIBUTE_UNIT_MSECONDS);
1268
1269 if (a->pretty_value < SK_MSECOND_VALID_MIN ||
1270 a->pretty_value > SK_MSECOND_VALID_LONG_MAX) {
1271 a->pretty_unit = SK_SMART_ATTRIBUTE_UNIT_UNKNOWN;
1272 d->attribute_verification_bad = TRUE;
1273 }
1274 }
1275
1276 static void verify_sectors(SkDisk *d, SkSmartAttributeParsedData *a) {
1277 uint64_t max_sectors;
1278
1279 assert(d);
1280 assert(a);
1281 assert(a->pretty_unit == SK_SMART_ATTRIBUTE_UNIT_SECTORS);
1282
1283 max_sectors = d->size / 512ULL;
1284
1285 if (a->pretty_value == 0xffffffffULL ||
1286 a->pretty_value == 0xffffffffffffULL ||
1287 (max_sectors > 0 && a->pretty_value > max_sectors)) {
1288 a->pretty_value = SK_SMART_ATTRIBUTE_UNIT_UNKNOWN;
1289 d->attribute_verification_bad = TRUE;
1290 } else {
1291 if ((!strcmp(a->name, "reallocated-sector-count") ||
1292 !strcmp(a->name, "current-pending-sector")) &&
1293 a->pretty_value > 0)
1294 a->warn = TRUE;
1295 }
1296 }
1297
1298 /* This data is stolen from smartmontools */
1299
1300 /* %STRINGPOOLSTART% */
1301 static const SkSmartAttributeInfo const attribute_info[256] = {
1302 [1] = { "raw-read-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1303 [2] = { "throughput-performance", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1304 [3] = { "spin-up-time", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_short_time },
1305 [4] = { "start-stop-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1306 [5] = { "reallocated-sector-count", SK_SMART_ATTRIBUTE_UNIT_SECTORS, verify_sectors },
1307 [6] = { "read-channel-margin", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1308 [7] = { "seek-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1309 [8] = { "seek-time-performance", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1310 [9] = { "power-on-hours", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time },
1311 [10] = { "spin-retry-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1312 [11] = { "calibration-retry-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1313 [12] = { "power-cycle-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1314 [13] = { "read-soft-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1315 [170] = { "available-reserved-space", SK_SMART_ATTRIBUTE_UNIT_PERCENT, NULL },
1316 [171] = { "program-fail-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1317 [172] = { "erase-fail-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1318 [175] = { "program-fail-count-chip", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1319 [176] = { "erase-fail-count-chip", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1320 [177] = { "wear-leveling-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1321 [178] = { "used-reserved-blocks-chip", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1322 [179] = { "used-reserved-blocks-total", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1323 [180] = { "unused-reserved-blocks", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1324 [181] = { "program-fail-count-total", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1325 [182] = { "erase-fail-count-total", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1326 [183] = { "runtime-bad-block-total", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1327 [184] = { "end-to-end-error", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1328 [187] = { "reported-uncorrect", SK_SMART_ATTRIBUTE_UNIT_SECTORS, verify_sectors },
1329 [188] = { "command-timeout", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1330 [189] = { "high-fly-writes", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1331 [190] = { "airflow-temperature-celsius", SK_SMART_ATTRIBUTE_UNIT_MKELVIN, verify_temperature },
1332 [191] = { "g-sense-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1333 [192] = { "power-off-retract-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1334 [193] = { "load-cycle-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1335 [194] = { "temperature-celsius-2", SK_SMART_ATTRIBUTE_UNIT_MKELVIN, verify_temperature },
1336 [195] = { "hardware-ecc-recovered", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1337 [196] = { "reallocated-event-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1338 [197] = { "current-pending-sector", SK_SMART_ATTRIBUTE_UNIT_SECTORS, verify_sectors },
1339 [198] = { "offline-uncorrectable", SK_SMART_ATTRIBUTE_UNIT_SECTORS, verify_sectors },
1340 [199] = { "udma-crc-error-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1341 [200] = { "multi-zone-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1342 [201] = { "soft-read-error-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1343 [202] = { "ta-increase-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1344 [203] = { "run-out-cancel", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1345 [204] = { "shock-count-write-open", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1346 [205] = { "shock-rate-write-open", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1347 [206] = { "flying-height", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1348 [207] = { "spin-high-current", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1349 [208] = { "spin-buzz", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1350 [209] = { "offline-seek-performance", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1351 [220] = { "disk-shift", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1352 [221] = { "g-sense-error-rate-2", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1353 [222] = { "loaded-hours", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time },
1354 [223] = { "load-retry-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1355 [224] = { "load-friction", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1356 [225] = { "load-cycle-count-2", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1357 [226] = { "load-in-time", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_short_time },
1358 [227] = { "torq-amp-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1359 [228] = { "power-off-retract-count-2", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL },
1360 [230] = { "head-amplitude", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1361 [231] = { "temperature-celsius", SK_SMART_ATTRIBUTE_UNIT_MKELVIN, verify_temperature },
1362
1363 /* http://www.adtron.com/pdf/SMART_for_XceedLite_SATA_RevA.pdf */
1364 [232] = { "endurance-remaining", SK_SMART_ATTRIBUTE_UNIT_PERCENT, NULL },
1365 [233] = { "power-on-seconds-2", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1366 [234] = { "uncorrectable-ecc-count", SK_SMART_ATTRIBUTE_UNIT_SECTORS, NULL },
1367 [235] = { "good-block-rate", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL },
1368
1369 [240] = { "head-flying-hours", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time },
1370 [241] = { "total-lbas-written", SK_SMART_ATTRIBUTE_UNIT_MB, NULL },
1371 [242] = { "total-lbas-read", SK_SMART_ATTRIBUTE_UNIT_MB, NULL },
1372 [250] = { "read-error-retry-rate", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL }
1373 };
1374 /* %STRINGPOOLSTOP% */
1375
1376 typedef enum SkSmartQuirk {
1377 SK_SMART_QUIRK_9_POWERONMINUTES = 0x000001,
1378 SK_SMART_QUIRK_9_POWERONSECONDS = 0x000002,
1379 SK_SMART_QUIRK_9_POWERONHALFMINUTES = 0x000004,
1380 SK_SMART_QUIRK_192_EMERGENCYRETRACTCYCLECT = 0x000008,
1381 SK_SMART_QUIRK_193_LOADUNLOAD = 0x000010,
1382 SK_SMART_QUIRK_194_10XCELSIUS = 0x000020,
1383 SK_SMART_QUIRK_194_UNKNOWN = 0x000040,
1384 SK_SMART_QUIRK_200_WRITEERRORCOUNT = 0x000080,
1385 SK_SMART_QUIRK_201_DETECTEDTACOUNT = 0x000100,
1386 SK_SMART_QUIRK_5_UNKNOWN = 0x000200,
1387 SK_SMART_QUIRK_9_UNKNOWN = 0x000400,
1388 SK_SMART_QUIRK_197_UNKNOWN = 0x000800,
1389 SK_SMART_QUIRK_198_UNKNOWN = 0x001000,
1390 SK_SMART_QUIRK_190_UNKNOWN = 0x002000,
1391 SK_SMART_QUIRK_232_AVAILABLERESERVEDSPACE = 0x004000,
1392 SK_SMART_QUIRK_233_MEDIAWEAROUTINDICATOR = 0x008000,
1393 SK_SMART_QUIRK_225_TOTALLBASWRITTEN = 0x010000,
1394 SK_SMART_QUIRK_4_UNUSED = 0x020000,
1395 SK_SMART_QUIRK_226_TIMEWORKLOADMEDIAWEAR = 0x040000,
1396 SK_SMART_QUIRK_227_TIMEWORKLOADHOSTREADS = 0x080000,
1397 SK_SMART_QUIRK_228_WORKLOADTIMER = 0x100000,
1398 SK_SMART_QUIRK_3_UNUSED = 0x200000
1399 } SkSmartQuirk;
1400
1401 /* %STRINGPOOLSTART% */
1402 static const char *quirk_name[] = {
1403 "9_POWERONMINUTES",
1404 "9_POWERONSECONDS",
1405 "9_POWERONHALFMINUTES",
1406 "192_EMERGENCYRETRACTCYCLECT",
1407 "193_LOADUNLOAD",
1408 "194_10XCELSIUS",
1409 "194_UNKNOWN",
1410 "200_WRITEERRORCOUNT",
1411 "201_DETECTEDTACOUNT",
1412 "5_UNKNOWN",
1413 "9_UNKNOWN",
1414 "197_UNKNOWN",
1415 "198_UNKNOWN",
1416 "190_UNKNOWN",
1417 "232_AVAILABLERESERVEDSPACE",
1418 "233_MEDIAWEAROUTINDICATOR",
1419 "225_TOTALLBASWRITTEN",
1420 "4_UNUSED",
1421 "226_TIMEWORKLOADMEDIAWEAR",
1422 "227_TIMEWORKLOADHOSTREADS",
1423 "228_WORKLOADTIMER",
1424 "3_UNUSED",
1425 NULL
1426 };
1427 /* %STRINGPOOLSTOP% */
1428
1429 typedef struct SkSmartQuirkDatabase {
1430 const char *model;
1431 const char *firmware;
1432 SkSmartQuirk quirk;
1433 } SkSmartQuirkDatabase;
1434
1435 static const SkSmartQuirkDatabase quirk_database[] = { {
1436
1437 /*** Fujitsu */
1438 "^("
1439 "FUJITSU MHY2120BH|"
1440 "FUJITSU MHY2250BH"
1441 ")$",
1442 "^0085000B$", /* seems to be specific to this firmware */
1443 SK_SMART_QUIRK_9_POWERONMINUTES|
1444 SK_SMART_QUIRK_197_UNKNOWN|
1445 SK_SMART_QUIRK_198_UNKNOWN
1446 }, {
1447 "^FUJITSU MHR2040AT$",
1448 NULL,
1449 SK_SMART_QUIRK_9_POWERONSECONDS|
1450 SK_SMART_QUIRK_192_EMERGENCYRETRACTCYCLECT|
1451 SK_SMART_QUIRK_200_WRITEERRORCOUNT
1452 }, {
1453 "^FUJITSU MHS20[6432]0AT( .)?$",
1454 NULL,
1455 SK_SMART_QUIRK_9_POWERONSECONDS|
1456 SK_SMART_QUIRK_192_EMERGENCYRETRACTCYCLECT|
1457 SK_SMART_QUIRK_200_WRITEERRORCOUNT|
1458 SK_SMART_QUIRK_201_DETECTEDTACOUNT
1459 }, {
1460 "^("
1461 "FUJITSU M1623TAU|"
1462 "FUJITSU MHG2...ATU?.*|"
1463 "FUJITSU MHH2...ATU?.*|"
1464 "FUJITSU MHJ2...ATU?.*|"
1465 "FUJITSU MHK2...ATU?.*|"
1466 "FUJITSU MHL2300AT|"
1467 "FUJITSU MHM2(20|15|10|06)0AT|"
1468 "FUJITSU MHN2...AT|"
1469 "FUJITSU MHR2020AT|"
1470 "FUJITSU MHT2...(AH|AS|AT|BH)U?.*|"
1471 "FUJITSU MHU2...ATU?.*|"
1472 "FUJITSU MHV2...(AH|AS|AT|BH|BS|BT).*|"
1473 "FUJITSU MP[A-G]3...A[HTEV]U?.*"
1474 ")$",
1475 NULL,
1476 SK_SMART_QUIRK_9_POWERONSECONDS
1477 }, {
1478
1479 /*** Samsung ***/
1480 "^("
1481 "SAMSUNG SV4012H|"
1482 "SAMSUNG SP(0451|08[0124]2|12[0145]3|16[0145]4)[CN]"
1483 ")$",
1484 NULL,
1485 SK_SMART_QUIRK_9_POWERONHALFMINUTES
1486 }, {
1487 "^("
1488 "SAMSUNG SV0412H|"
1489 "SAMSUNG SV1204H"
1490 ")$",
1491 NULL,
1492 SK_SMART_QUIRK_9_POWERONHALFMINUTES|
1493 SK_SMART_QUIRK_194_10XCELSIUS
1494 }, {
1495 "^SAMSUNG SP40A2H$",
1496 "^RR100-07$",
1497 SK_SMART_QUIRK_9_POWERONHALFMINUTES
1498 }, {
1499 "^SAMSUNG SP80A4H$",
1500 "^RT100-06$",
1501 SK_SMART_QUIRK_9_POWERONHALFMINUTES
1502 }, {
1503 "^SAMSUNG SP8004H$",
1504 "^QW100-61$",
1505 SK_SMART_QUIRK_9_POWERONHALFMINUTES
1506 }, {
1507
1508 /*** Maxtor */
1509 "^("
1510 "Maxtor 2B0(0[468]|1[05]|20)H1|"
1511 "Maxtor 4G(120J6|160J[68])|"
1512 "Maxtor 4D0(20H1|40H2|60H3|80H4)"
1513 ")$",
1514 NULL,
1515 SK_SMART_QUIRK_9_POWERONMINUTES|
1516 SK_SMART_QUIRK_194_UNKNOWN
1517 }, {
1518 "^("
1519 "Maxtor 2F0[234]0[JL]0|"
1520 "Maxtor 8(1280A2|2160A4|2560A4|3840A6|4000A6|5120A8)|"
1521 "Maxtor 8(2160D2|3228D3|3240D3|4320D4|6480D6|8400D8|8455D8)|"
1522 "Maxtor 9(0510D4|0576D4|0648D5|0720D5|0840D6|0845D6|0864D6|1008D7|1080D8|1152D8)|"
1523 "Maxtor 9(1(360|350|202)D8|1190D7|10[12]0D6|0840D5|06[48]0D4|0510D3|1(350|202)E8|1010E6|0840E5|0640E4)|"
1524 "Maxtor 9(0512D2|0680D3|0750D3|0913D4|1024D4|1360D6|1536D6|1792D7|2048D8)|"
1525 "Maxtor 9(2732U8|2390U7|204[09]U6|1707U5|1366U4|1024U3|0845U3|0683U2)|"
1526 "Maxtor 4(R0[68]0[JL]0|R1[26]0L0|A160J0|R120L4)|"
1527 "Maxtor (91728D8|91512D7|91303D6|91080D5|90845D4|90645D3|90648D[34]|90432D2)|"
1528 "Maxtor 9(0431U1|0641U2|0871U2|1301U3|1741U4)|"
1529 "Maxtor (94091U8|93071U6|92561U5|92041U4|91731U4|91531U3|91361U3|91021U2|90841U2|90651U2)|"
1530 "Maxtor (33073U4|32049U3|31536U2|30768U1|33073H4|32305H3|31536H2|30768H1)|"
1531 "Maxtor (93652U8|92739U6|91826U4|91369U3|90913U2|90845U2|90435U1)|"
1532 "Maxtor 9(0684U2|1024U2|1362U3|1536U3|2049U4|2562U5|3073U6|4098U8)|"
1533 "Maxtor (54098[UH]8|53073[UH]6|52732[UH]6|52049[UH]4|51536[UH]3|51369[UH]3|51024[UH]2)|"
1534 "Maxtor 3(1024H1|1535H2|2049H2|3073H3|4098H4)( B)?|"
1535 "Maxtor 5(4610H6|4098H6|3073H4|2049H3|1536H2|1369H2|1023H2)|"
1536 "Maxtor 9(1023U2|1536U2|2049U3|2305U3|3073U4|4610U6|6147U8)|"
1537 "Maxtor 9(1023H2|1536H2|2049H3|2305H3|3073H4|4098H6|4610H6|6147H8)|"
1538 "Maxtor 5T0(60H6|40H4|30H3|20H2|10H1)|"
1539 "Maxtor (98196H8|96147H6)|"
1540 "Maxtor 4W(100H6|080H6|060H4|040H3|030H2)|"
1541 "Maxtor 6(E0[234]|K04)0L0|"
1542 "Maxtor 6(B(30|25|20|16|12|10|08)0[MPRS]|L(080[MLP]|(100|120)[MP]|160[MP]|200[MPRS]|250[RS]|300[RS]))0|"
1543 "Maxtor 6Y((060|080|120|160)L0|(060|080|120|160|200|250)P0|(060|080|120|160|200|250)M0)|"
1544 "Maxtor 7Y250[PM]0|"
1545 "Maxtor [45]A(25|30|32)0[JN]0|"
1546 "Maxtor 7L(25|30)0[SR]0"
1547 ")$",
1548 NULL,
1549 SK_SMART_QUIRK_9_POWERONMINUTES
1550 }, {
1551
1552
1553 /*** Hitachi */
1554 "^("
1555 "HITACHI_DK14FA-20B|"
1556 "HITACHI_DK23..-..B?|"
1557 "HITACHI_DK23FA-20J|HTA422020F9AT[JN]0|"
1558 "HE[JN]4230[23]0F9AT00|"
1559 "HTC4260[23]0G5CE00|HTC4260[56]0G8CE00"
1560 ")$",
1561 NULL,
1562 SK_SMART_QUIRK_9_POWERONMINUTES|
1563 SK_SMART_QUIRK_193_LOADUNLOAD
1564 }, {
1565 "^HTS541010G9SA00$",
1566 "^MBZOC60P$",
1567 SK_SMART_QUIRK_5_UNKNOWN
1568 }, {
1569
1570 /*** Apple SSD (?) http://bugs.freedesktop.org/show_bug.cgi?id=24700
1571 https://bugs.launchpad.net/ubuntu/+source/gnome-disk-utility/+bug/438136/comments/4 */
1572 "^MCCOE64GEMPP$",
1573 "^2.9.0[3-9]$",
1574 SK_SMART_QUIRK_5_UNKNOWN|
1575 SK_SMART_QUIRK_190_UNKNOWN
1576 }, {
1577
1578 /*** Intel */
1579 "^INTEL SSDSA2(CT|BT|CW|BW)[0-9]{3}G3.*$", /* 320 Series */
1580 NULL,
1581 SK_SMART_QUIRK_3_UNUSED|
1582 SK_SMART_QUIRK_4_UNUSED|
1583 SK_SMART_QUIRK_225_TOTALLBASWRITTEN|
1584 SK_SMART_QUIRK_226_TIMEWORKLOADMEDIAWEAR|
1585 SK_SMART_QUIRK_227_TIMEWORKLOADHOSTREADS|
1586 SK_SMART_QUIRK_228_WORKLOADTIMER|
1587 SK_SMART_QUIRK_232_AVAILABLERESERVEDSPACE|
1588 SK_SMART_QUIRK_233_MEDIAWEAROUTINDICATOR
1589 }, {
1590 NULL,
1591 NULL,
1592 0
1593 }
1594 };
1595
1596 static int match(const char*regex, const char *s, SkBool *result) {
1597 int k;
1598 regex_t re;
1599
1600 *result = FALSE;
1601
1602 if (regcomp(&re, regex, REG_EXTENDED|REG_NOSUB) != 0) {
1603 errno = EINVAL;
1604 return -1;
1605 }
1606
1607 if ((k = regexec(&re, s, 0, NULL, 0)) != 0) {
1608
1609 if (k != REG_NOMATCH) {
1610 regfree(&re);
1611 errno = EINVAL;
1612 return -1;
1613 }
1614
1615 } else
1616 *result = TRUE;
1617
1618 regfree(&re);
1619
1620 return 0;
1621 }
1622
1623 static int lookup_quirks(const char *model, const char *firmware, SkSmartQuirk *quirk) {
1624 int k;
1625 const SkSmartQuirkDatabase *db;
1626
1627 *quirk = 0;
1628
1629 for (db = quirk_database; db->model || db->firmware; db++) {
1630
1631 if (db->model) {
1632 SkBool matching = FALSE;
1633
1634 if ((k = match(db->model, model, &matching)) < 0)
1635 return k;
1636
1637 if (!matching)
1638 continue;
1639 }
1640
1641 if (db->firmware) {
1642 SkBool matching = FALSE;
1643
1644 if ((k = match(db->firmware, firmware, &matching)) < 0)
1645 return k;
1646
1647 if (!matching)
1648 continue;
1649 }
1650
1651 *quirk = db->quirk;
1652 return 0;
1653 }
1654
1655 return 0;
1656 }
1657
1658 static const SkSmartAttributeInfo *lookup_attribute(SkDisk *d, uint8_t id) {
1659 const SkIdentifyParsedData *ipd;
1660 SkSmartQuirk quirk = 0;
1661
1662 /* These are the complex ones */
1663 if (sk_disk_identify_parse(d, &ipd) < 0)
1664 return NULL;
1665
1666 if (lookup_quirks(ipd->model, ipd->firmware, &quirk) < 0)
1667 return NULL;
1668
1669 if (quirk) {
1670 switch (id) {
1671 case 3:
1672 /* %STRINGPOOLSTART% */
1673 if (quirk & SK_SMART_QUIRK_3_UNUSED) {
1674 static const SkSmartAttributeInfo a = {
1675 "spin-up-time", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL
1676 };
1677 return &a;
1678 }
1679 /* %STRINGPOOLSTOP% */
1680
1681 break;
1682
1683 case 4:
1684 /* %STRINGPOOLSTART% */
1685 if (quirk & SK_SMART_QUIRK_4_UNUSED) {
1686 static const SkSmartAttributeInfo a = {
1687 "start-stop-count", SK_SMART_ATTRIBUTE_UNIT_UNKNOWN, NULL
1688 };
1689 return &a;
1690 }
1691 /* %STRINGPOOLSTOP% */
1692
1693 break;
1694
1695 case 5:
1696 if (quirk & SK_SMART_QUIRK_5_UNKNOWN)
1697 return NULL;
1698
1699 break;
1700
1701 case 9:
1702 /* %STRINGPOOLSTART% */
1703 if (quirk & SK_SMART_QUIRK_9_POWERONMINUTES) {
1704 static const SkSmartAttributeInfo a = {
1705 "power-on-minutes", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time
1706 };
1707 return &a;
1708
1709 } else if (quirk & SK_SMART_QUIRK_9_POWERONSECONDS) {
1710 static const SkSmartAttributeInfo a = {
1711 "power-on-seconds", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time
1712 };
1713 return &a;
1714
1715 } else if (quirk & SK_SMART_QUIRK_9_POWERONHALFMINUTES) {
1716 static const SkSmartAttributeInfo a = {
1717 "power-on-half-minutes", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, verify_long_time
1718 };
1719 return &a;
1720 } else if (quirk & SK_SMART_QUIRK_9_UNKNOWN)
1721 return NULL;
1722 /* %STRINGPOOLSTOP% */
1723
1724 break;
1725
1726 case 190:
1727 if (quirk & SK_SMART_QUIRK_190_UNKNOWN)
1728 return NULL;
1729
1730 break;
1731
1732 case 192:
1733 /* %STRINGPOOLSTART% */
1734 if (quirk & SK_SMART_QUIRK_192_EMERGENCYRETRACTCYCLECT) {
1735 static const SkSmartAttributeInfo a = {
1736 "emergency-retract-cycle-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL
1737 };
1738 return &a;
1739 }
1740 /* %STRINGPOOLSTOP% */
1741
1742 break;
1743
1744 case 194:
1745 /* %STRINGPOOLSTART% */
1746 if (quirk & SK_SMART_QUIRK_194_10XCELSIUS) {
1747 static const SkSmartAttributeInfo a = {
1748 "temperature-centi-celsius", SK_SMART_ATTRIBUTE_UNIT_MKELVIN, verify_temperature
1749 };
1750 return &a;
1751 } else if (quirk & SK_SMART_QUIRK_194_UNKNOWN)
1752 return NULL;
1753 /* %STRINGPOOLSTOP% */
1754
1755 break;
1756
1757 case 197:
1758 if (quirk & SK_SMART_QUIRK_197_UNKNOWN)
1759 return NULL;
1760
1761 break;
1762
1763 case 198:
1764 if (quirk & SK_SMART_QUIRK_198_UNKNOWN)
1765 return NULL;
1766
1767 break;
1768
1769 case 200:
1770 /* %STRINGPOOLSTART% */
1771 if (quirk & SK_SMART_QUIRK_200_WRITEERRORCOUNT) {
1772 static const SkSmartAttributeInfo a = {
1773 "write-error-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL
1774 };
1775 return &a;
1776 }
1777 /* %STRINGPOOLSTOP% */
1778
1779 break;
1780
1781 case 201:
1782 /* %STRINGPOOLSTART% */
1783 if (quirk & SK_SMART_QUIRK_201_DETECTEDTACOUNT) {
1784 static const SkSmartAttributeInfo a = {
1785 "detected-ta-count", SK_SMART_ATTRIBUTE_UNIT_NONE, NULL
1786 };
1787 return &a;
1788 }
1789 /* %STRINGPOOLSTOP% */
1790
1791 break;
1792
1793 case 225:
1794 /* %STRINGPOOLSTART% */
1795 if (quirk & SK_SMART_QUIRK_225_TOTALLBASWRITTEN) {
1796 static const SkSmartAttributeInfo a = {
1797 "total-lbas-written", SK_SMART_ATTRIBUTE_UNIT_MB, NULL
1798 };
1799 return &a;
1800 }
1801 /* %STRINGPOOLSTOP% */
1802
1803 break;
1804
1805 case 226:
1806 /* %STRINGPOOLSTART% */
1807 if (quirk & SK_SMART_QUIRK_226_TIMEWORKLOADMEDIAWEAR) {
1808 static const SkSmartAttributeInfo a = {
1809 "timed-workload-media-wear", SK_SMART_ATTRIBUTE_UNIT_SMALL_PERCENT, NULL
1810 };
1811 return &a;
1812 }
1813 /* %STRINGPOOLSTOP% */
1814
1815 break;
1816
1817 case 227:
1818 /* %STRINGPOOLSTART% */
1819 if (quirk & SK_SMART_QUIRK_227_TIMEWORKLOADHOSTREADS) {
1820 static const SkSmartAttributeInfo a = {
1821 "timed-workload-host-reads", SK_SMART_ATTRIBUTE_UNIT_SMALL_PERCENT, NULL
1822 };
1823 return &a;
1824 }
1825 /* %STRINGPOOLSTOP% */
1826
1827 break;
1828
1829 case 228:
1830 /* %STRINGPOOLSTART% */
1831 if (quirk & SK_SMART_QUIRK_228_WORKLOADTIMER) {
1832 static const SkSmartAttributeInfo a = {
1833 "workload-timer", SK_SMART_ATTRIBUTE_UNIT_MSECONDS, NULL
1834 };
1835 return &a;
1836 }
1837 /* %STRINGPOOLSTOP% */
1838
1839 break;
1840
1841 case 232:
1842 /* %STRINGPOOLSTART% */
1843 if (quirk & SK_SMART_QUIRK_232_AVAILABLERESERVEDSPACE) {
1844 static const SkSmartAttributeInfo a = {
1845 "available-reserved-space", SK_SMART_ATTRIBUTE_UNIT_PERCENT, NULL
1846 };
1847 return &a;
1848 }
1849 /* %STRINGPOOLSTOP% */
1850 break;
1851
1852 case 233:
1853 /* %STRINGPOOLSTART% */
1854 if (quirk & SK_SMART_QUIRK_233_MEDIAWEAROUTINDICATOR) {
1855 static const SkSmartAttributeInfo a = {
1856 "media-wearout-indicator", SK_SMART_ATTRIBUTE_UNIT_PERCENT, NULL
1857 };
1858 return &a;
1859 }
1860 /* %STRINGPOOLSTOP% */
1861 break;
1862
1863 }
1864 }
1865
1866 /* These are the simple cases */
1867 if (attribute_info[id].name)
1868 return &attribute_info[id];
1869
1870 return NULL;
1871 }
1872
1873 int sk_disk_smart_parse(SkDisk *d, const SkSmartParsedData **spd) {
1874
1875 if (!d->smart_data_valid) {
1876 errno = ENOENT;
1877 return -1;
1878 }
1879
1880 switch (d->smart_data[362]) {
1881 case 0x00:
1882 case 0x80:
1883 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_NEVER;
1884 break;
1885
1886 case 0x02:
1887 case 0x82:
1888 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_SUCCESS;
1889 break;
1890
1891 case 0x03:
1892 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_INPROGRESS;
1893 break;
1894
1895 case 0x04:
1896 case 0x84:
1897 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_SUSPENDED;
1898 break;
1899
1900 case 0x05:
1901 case 0x85:
1902 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_ABORTED;
1903 break;
1904
1905 case 0x06:
1906 case 0x86:
1907 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_FATAL;
1908 break;
1909
1910 default:
1911 d->smart_parsed_data.offline_data_collection_status = SK_SMART_OFFLINE_DATA_COLLECTION_STATUS_UNKNOWN;
1912 break;
1913 }
1914
1915 d->smart_parsed_data.self_test_execution_percent_remaining = 10*(d->smart_data[363] & 0xF);
1916 d->smart_parsed_data.self_test_execution_status = (d->smart_data[363] >> 4) & 0xF;
1917
1918 d->smart_parsed_data.total_offline_data_collection_seconds = (uint16_t) d->smart_data[364] | ((uint16_t) d->smart_data[365] << 8);
1919
1920 d->smart_parsed_data.conveyance_test_available = disk_smart_is_conveyance_test_available(d);
1921 d->smart_parsed_data.short_and_extended_test_available = disk_smart_is_short_and_extended_test_available(d);
1922 d->smart_parsed_data.start_test_available = disk_smart_is_start_test_available(d);
1923 d->smart_parsed_data.abort_test_available = disk_smart_is_abort_test_available(d);
1924
1925 d->smart_parsed_data.short_test_polling_minutes = d->smart_data[372];
1926 d->smart_parsed_data.extended_test_polling_minutes = d->smart_data[373] != 0xFF ? d->smart_data[373] : ((uint16_t) d->smart_data[376] << 8 | (uint16_t) d->smart_data[375]);
1927 d->smart_parsed_data.conveyance_test_polling_minutes = d->smart_data[374];
1928
1929 *spd = &d->smart_parsed_data;
1930
1931 return 0;
1932 }
1933
1934 static void find_threshold(SkDisk *d, SkSmartAttributeParsedData *a) {
1935 uint8_t *p;
1936 unsigned n;
1937
1938 if (!d->smart_thresholds_valid)
1939 goto fail;
1940
1941 for (n = 0, p = d->smart_thresholds+2; n < 30; n++, p+=12)
1942 if (p[0] == a->id)
1943 break;
1944
1945 if (n >= 30)
1946 goto fail;
1947
1948 a->threshold = p[1];
1949 a->threshold_valid = p[1] != 0xFE;
1950
1951 a->good_now_valid = FALSE;
1952 a->good_now = TRUE;
1953 a->good_in_the_past_valid = FALSE;
1954 a->good_in_the_past = TRUE;
1955
1956 /* Always-Fail and Always-Passing thresholds are not relevant
1957 * for our assessment. */
1958 if (p[1] >= 1 && p[1] <= 0xFD) {
1959
1960 if (a->worst_value_valid) {
1961 a->good_in_the_past = a->good_in_the_past && (a->worst_value > a->threshold);
1962 a->good_in_the_past_valid = TRUE;
1963 }
1964
1965 if (a->current_value_valid) {
1966 a->good_now = a->good_now && (a->current_value > a->threshold);
1967 a->good_now_valid = TRUE;
1968 }
1969 }
1970
1971 a->warn =
1972 (a->good_now_valid && !a->good_now) ||
1973 (a->good_in_the_past_valid && !a->good_in_the_past);
1974
1975 return;
1976
1977 fail:
1978 a->threshold_valid = FALSE;
1979 a->good_now_valid = FALSE;
1980 a->good_in_the_past_valid = FALSE;
1981 a->warn = FALSE;
1982 }
1983
1984 int sk_disk_smart_parse_attributes(SkDisk *d, SkSmartAttributeParseCallback cb, void* userdata) {
1985 uint8_t *p;
1986 unsigned n;
1987
1988 if (!d->smart_data_valid) {
1989 errno = ENOENT;
1990 return -1;
1991 }
1992
1993 for (n = 0, p = d->smart_data + 2; n < 30; n++, p+=12) {
1994 SkSmartAttributeParsedData a;
1995 const SkSmartAttributeInfo *i;
1996 char *an = NULL;
1997
1998 if (p[0] == 0)
1999 continue;
2000
2001 memset(&a, 0, sizeof(a));
2002 a.id = p[0];
2003 a.current_value = p[3];
2004 a.current_value_valid = p[3] >= 1 && p[3] <= 0xFD;
2005 a.worst_value = p[4];
2006 a.worst_value_valid = p[4] >= 1 && p[4] <= 0xFD;
2007
2008 a.flags = ((uint16_t) p[2] << 8) | p[1];
2009 a.prefailure = !!(p[1] & 1);
2010 a.online = !!(p[1] & 2);
2011
2012 memcpy(a.raw, p+5, 6);
2013
2014 if ((i = lookup_attribute(d, p[0]))) {
2015 a.name = _P(i->name);
2016 a.pretty_unit = i->unit;
2017 } else {
2018 if (asprintf(&an, "attribute-%u", a.id) < 0) {
2019 errno = ENOMEM;
2020 return -1;
2021 }
2022
2023 a.name = an;
2024 a.pretty_unit = SK_SMART_ATTRIBUTE_UNIT_UNKNOWN;
2025 }
2026
2027 make_pretty(&a);
2028
2029 find_threshold(d, &a);
2030
2031 if (i && i->verify)
2032 i->verify(d, &a);
2033
2034 cb(d, &a, userdata);
2035 free(an);
2036 }
2037
2038 return 0;
2039 }
2040
2041 static const char *yes_no(SkBool b) {
2042 return b ? "yes" : "no";
2043 }
2044
2045 const char* sk_smart_attribute_unit_to_string(SkSmartAttributeUnit unit) {
2046
2047 /* %STRINGPOOLSTART% */
2048 const char * const map[] = {
2049 [SK_SMART_ATTRIBUTE_UNIT_UNKNOWN] = NULL,
2050 [SK_SMART_ATTRIBUTE_UNIT_NONE] = "",
2051 [SK_SMART_ATTRIBUTE_UNIT_MSECONDS] = "ms",
2052 [SK_SMART_ATTRIBUTE_UNIT_SECTORS] = "sectors",
2053 [SK_SMART_ATTRIBUTE_UNIT_MKELVIN] = "mK",
2054 [SK_SMART_ATTRIBUTE_UNIT_PERCENT] = "%",
2055 [SK_SMART_ATTRIBUTE_UNIT_SMALL_PERCENT] = "%",
2056 [SK_SMART_ATTRIBUTE_UNIT_MB] = "MB"
2057 };
2058 /* %STRINGPOOLSTOP% */
2059
2060 if (unit >= _SK_SMART_ATTRIBUTE_UNIT_MAX)
2061 return NULL;
2062
2063 return _P(map[unit]);
2064 }
2065
2066 struct attr_helper {
2067 uint64_t *value;
2068 SkBool found;
2069 };
2070
2071 static void temperature_cb(SkDisk *d, const SkSmartAttributeParsedData *a, struct attr_helper *ah) {
2072
2073 if (a->pretty_unit != SK_SMART_ATTRIBUTE_UNIT_MKELVIN)
2074 return;
2075
2076 if (!strcmp(a->name, "temperature-centi-celsius") ||
2077 !strcmp(a->name, "temperature-celsius") ||
2078 !strcmp(a->name, "temperature-celsius-2") ||
2079 !strcmp(a->name, "airflow-temperature-celsius")) {
2080
2081 if (!ah->found || a->pretty_value > *ah->value)
2082 *ah->value = a->pretty_value;
2083
2084 ah->found = TRUE;
2085 }
2086 }
2087
2088 int sk_disk_smart_get_temperature(SkDisk *d, uint64_t *kelvin) {
2089 struct attr_helper ah;
2090
2091 assert(d);
2092 assert(kelvin);
2093
2094 ah.found = FALSE;
2095 ah.value = kelvin;
2096
2097 if (sk_disk_smart_parse_attributes(d, (SkSmartAttributeParseCallback) temperature_cb, &ah) < 0)
2098 return -1;
2099
2100 if (!ah.found) {
2101 errno = ENOENT;
2102 return -1;
2103 }
2104
2105 return 0;
2106 }
2107
2108 static void power_on_cb(SkDisk *d, const SkSmartAttributeParsedData *a, struct attr_helper *ah) {
2109
2110 if (a->pretty_unit != SK_SMART_ATTRIBUTE_UNIT_MSECONDS)
2111 return;
2112
2113 if (!strcmp(a->name, "power-on-minutes") ||
2114 !strcmp(a->name, "power-on-seconds") ||
2115 !strcmp(a->name, "power-on-seconds-2") ||
2116 !strcmp(a->name, "power-on-half-minutes") ||
2117 !strcmp(a->name, "power-on-hours")) {
2118
2119 if (!ah->found || a->pretty_value > *ah->value)
2120 *ah->value = a->pretty_value;
2121
2122 ah->found = TRUE;
2123 }
2124 }
2125
2126 int sk_disk_smart_get_power_on(SkDisk *d, uint64_t *mseconds) {
2127 struct attr_helper ah;
2128
2129 assert(d);
2130 assert(mseconds);
2131
2132 ah.found = FALSE;
2133 ah.value = mseconds;
2134
2135 if (sk_disk_smart_parse_attributes(d, (SkSmartAttributeParseCallback) power_on_cb, &ah) < 0)
2136 return -1;
2137
2138 if (!ah.found) {
2139 errno = ENOENT;
2140 return -1;
2141 }
2142
2143 return 0;
2144 }
2145
2146 static void power_cycle_cb(SkDisk *d, const SkSmartAttributeParsedData *a, struct attr_helper *ah) {
2147
2148 if (a->pretty_unit != SK_SMART_ATTRIBUTE_UNIT_NONE)
2149 return;
2150
2151 if (!strcmp(a->name, "power-cycle-count")) {
2152
2153 if (!ah->found || a->pretty_value > *ah->value)
2154 *ah->value = a->pretty_value;
2155
2156 ah->found = TRUE;
2157 }
2158 }
2159
2160 int sk_disk_smart_get_power_cycle(SkDisk *d, uint64_t *count) {
2161 struct attr_helper ah;
2162
2163 assert(d);
2164 assert(count);
2165
2166 ah.found = FALSE;
2167 ah.value = count;
2168
2169 if (sk_disk_smart_parse_attributes(d, (SkSmartAttributeParseCallback) power_cycle_cb, &ah) < 0)
2170 return -1;
2171
2172 if (!ah.found) {
2173 errno = ENOENT;
2174 return -1;
2175 }
2176
2177 return 0;
2178 }
2179
2180 static void fill_cache_cb(SkDisk *d, const SkSmartAttributeParsedData *a, void* userdata) {
2181
2182 if (a->prefailure) {
2183 if (a->good_now_valid && !a->good_now)
2184 d->bad_attribute_now = TRUE;
2185
2186 if (a->good_in_the_past_valid && !a->good_in_the_past)
2187 d->bad_attribute_in_the_past = TRUE;
2188 }
2189
2190 if (a->pretty_unit != SK_SMART_ATTRIBUTE_UNIT_SECTORS)
2191 return;
2192
2193 if (!strcmp(a->name, "reallocated-sector-count")) {
2194 if (a->pretty_value > d->reallocated_sector_count)
2195 d->reallocated_sector_count = a->pretty_value;
2196 d->reallocated_sector_count_found = TRUE;
2197 }
2198
2199 if (!strcmp(a->name, "current-pending-sector")) {
2200 if (a->pretty_value > d->current_pending_sector)
2201 d->current_pending_sector = a->pretty_value;
2202 d->current_pending_sector_found = TRUE;
2203 }
2204 }
2205
2206 static int fill_cache(SkDisk *d) {
2207 if (d->attribute_cache_valid)
2208 return 0;
2209
2210 if (sk_disk_smart_parse_attributes(d, (SkSmartAttributeParseCallback) fill_cache_cb, NULL) >= 0) {
2211 d->attribute_cache_valid = TRUE;
2212 return 0;
2213 } else
2214 return -1;
2215 }
2216
2217 int sk_disk_smart_get_bad(SkDisk *d, uint64_t *sectors) {
2218 assert(d);
2219 assert(sectors);
2220
2221 if (fill_cache (d) < 0)
2222 return -1;
2223
2224 if (!d->reallocated_sector_count_found && !d->current_pending_sector_found) {
2225 errno = ENOENT;
2226 return -1;
2227 }
2228
2229 if (d->reallocated_sector_count_found && d->current_pending_sector_found)
2230 *sectors = d->reallocated_sector_count + d->current_pending_sector;
2231 else if (d->reallocated_sector_count_found)
2232 *sectors = d->reallocated_sector_count;
2233 else
2234 *sectors = d->current_pending_sector;
2235
2236 return 0;
2237 }
2238
2239 const char* sk_smart_overall_to_string(SkSmartOverall overall) {
2240
2241 /* %STRINGPOOLSTART% */
2242 const char * const map[] = {
2243 [SK_SMART_OVERALL_GOOD] = "GOOD",
2244 [SK_SMART_OVERALL_BAD_ATTRIBUTE_IN_THE_PAST] = "BAD_ATTRIBUTE_IN_THE_PAST",
2245 [SK_SMART_OVERALL_BAD_SECTOR] = "BAD_SECTOR",
2246 [SK_SMART_OVERALL_BAD_ATTRIBUTE_NOW] = "BAD_ATTRIBUTE_NOW",
2247 [SK_SMART_OVERALL_BAD_SECTOR_MANY] = "BAD_SECTOR_MANY",
2248 [SK_SMART_OVERALL_BAD_STATUS] = "BAD_STATUS",
2249 };
2250 /* %STRINGPOOLSTOP% */
2251
2252 if (overall >= _SK_SMART_OVERALL_MAX)
2253 return NULL;
2254
2255 return _P(map[overall]);
2256 }
2257
2258 static uint64_t u64log2(uint64_t n) {
2259 unsigned r;
2260
2261 if (n <= 1)
2262 return 0;
2263
2264 r = 0;
2265 for (;;) {
2266 n = n >> 1;
2267 if (!n)
2268 return r;
2269 r++;
2270 }
2271 }
2272
2273 int sk_disk_smart_get_overall(SkDisk *d, SkSmartOverall *overall) {
2274 SkBool good;
2275 uint64_t sectors, sector_threshold;
2276
2277 assert(d);
2278 assert(overall);
2279
2280 /* First, check SMART self-assesment */
2281 if (sk_disk_smart_status(d, &good) < 0)
2282 return -1;
2283
2284 if (!good) {
2285 *overall = SK_SMART_OVERALL_BAD_STATUS;
2286 return 0;
2287 }
2288
2289 /* Second, check if the number of bad sectors is greater than
2290 * a certain threshold */
2291 if (sk_disk_smart_get_bad(d, &sectors) < 0) {
2292 if (errno != ENOENT)
2293 return -1;
2294 sectors = 0;
2295 } else {
2296
2297 /* We use log2(n_sectors)*1024 as a threshold here. We
2298 * had to pick something, and this makes a bit of
2299 * sense, or doesn't it? */
2300 sector_threshold = u64log2(d->size/512) * 1024;
2301
2302 if (sectors >= sector_threshold) {
2303 *overall = SK_SMART_OVERALL_BAD_SECTOR_MANY;
2304 return 0;
2305 }
2306 }
2307
2308 /* Third, check if any of the SMART attributes is bad */
2309 if (fill_cache (d) < 0)
2310 return -1;
2311
2312 if (d->bad_attribute_now) {
2313 *overall = SK_SMART_OVERALL_BAD_ATTRIBUTE_NOW;
2314 return 0;
2315 }
2316
2317 /* Fourth, check if there are any bad sectors at all */
2318 if (sectors > 0) {
2319 *overall = SK_SMART_OVERALL_BAD_SECTOR;
2320 return 0;
2321 }
2322
2323 /* Fifth, check if any of the SMART attributes ever was bad */
2324 if (d->bad_attribute_in_the_past) {
2325 *overall = SK_SMART_OVERALL_BAD_ATTRIBUTE_IN_THE_PAST;
2326 return 0;
2327 }
2328
2329 /* Sixth, there's really nothing to complain about, so give it a pass */
2330 *overall = SK_SMART_OVERALL_GOOD;
2331 return 0;
2332 }
2333
2334 static char* print_name(char *s, size_t len, uint8_t id, const char *k) {
2335
2336 if (k)
2337 strncpy(s, k, len);
2338 else
2339 snprintf(s, len, "%u", id);
2340
2341 s[len-1] = 0;
2342
2343 return s;
2344 }
2345
2346 static char *print_value(char *s, size_t len, uint64_t pretty_value, SkSmartAttributeUnit pretty_unit) {
2347
2348 switch (pretty_unit) {
2349 case SK_SMART_ATTRIBUTE_UNIT_MSECONDS:
2350
2351 if (pretty_value >= 1000LLU*60LLU*60LLU*24LLU*365LLU)
2352 snprintf(s, len, "%0.1f years", ((double) pretty_value)/(1000.0*60*60*24*365));
2353 else if (pretty_value >= 1000LLU*60LLU*60LLU*24LLU*30LLU)
2354 snprintf(s, len, "%0.1f months", ((double) pretty_value)/(1000.0*60*60*24*30));
2355 else if (pretty_value >= 1000LLU*60LLU*60LLU*24LLU)
2356 snprintf(s, len, "%0.1f days", ((double) pretty_value)/(1000.0*60*60*24));
2357 else if (pretty_value >= 1000LLU*60LLU*60LLU)
2358 snprintf(s, len, "%0.1f h", ((double) pretty_value)/(1000.0*60*60));
2359 else if (pretty_value >= 1000LLU*60LLU)
2360 snprintf(s, len, "%0.1f min", ((double) pretty_value)/(1000.0*60));
2361 else if (pretty_value >= 1000LLU)
2362 snprintf(s, len, "%0.1f s", ((double) pretty_value)/(1000.0));
2363 else
2364 snprintf(s, len, "%llu ms", (unsigned long long) pretty_value);
2365
2366 break;
2367
2368 case SK_SMART_ATTRIBUTE_UNIT_MKELVIN:
2369 snprintf(s, len, "%0.1f C", ((double) pretty_value - 273150) / 1000);
2370 break;
2371
2372 case SK_SMART_ATTRIBUTE_UNIT_SECTORS:
2373 snprintf(s, len, "%llu sectors", (unsigned long long) pretty_value);
2374 break;
2375
2376 case SK_SMART_ATTRIBUTE_UNIT_PERCENT:
2377 snprintf(s, len, "%llu%%", (unsigned long long) pretty_value);
2378 break;
2379
2380 case SK_SMART_ATTRIBUTE_UNIT_SMALL_PERCENT:
2381 snprintf(s, len, "%0.3f%%", (double) pretty_value);
2382 break;
2383
2384 case SK_SMART_ATTRIBUTE_UNIT_MB:
2385 if (pretty_value >= 1000000LLU)
2386 snprintf(s, len, "%0.3f TB", (double) pretty_value / 1000000LLU);
2387 else if (pretty_value >= 1000LLU)
2388 snprintf(s, len, "%0.3f GB", (double) pretty_value / 1000LLU);
2389 else
2390 snprintf(s, len, "%llu MB", (unsigned long long) pretty_value);
2391 break;
2392
2393 case SK_SMART_ATTRIBUTE_UNIT_NONE:
2394 snprintf(s, len, "%llu", (unsigned long long) pretty_value);
2395 break;
2396
2397 case SK_SMART_ATTRIBUTE_UNIT_UNKNOWN:
2398 snprintf(s, len, "n/a");
2399 break;
2400
2401 case _SK_SMART_ATTRIBUTE_UNIT_MAX:
2402 assert(FALSE);
2403 }
2404
2405 s[len-1] = 0;
2406
2407 return s;
2408 }
2409
2410 #define HIGHLIGHT "\x1B[1m"
2411 #define ENDHIGHLIGHT "\x1B[0m"
2412
2413 static void disk_dump_attributes(SkDisk *d, const SkSmartAttributeParsedData *a, void* userdata) {
2414 char name[32];
2415 char pretty[32];
2416 char tt[32], tw[32], tc[32];
2417 SkBool highlight;
2418
2419 snprintf(tt, sizeof(tt), "%3u", a->threshold);
2420 tt[sizeof(tt)-1] = 0;
2421 snprintf(tw, sizeof(tw), "%3u", a->worst_value);
2422 tw[sizeof(tw)-1] = 0;
2423 snprintf(tc, sizeof(tc), "%3u", a->current_value);
2424 tc[sizeof(tc)-1] = 0;
2425
2426 highlight = a->warn && isatty(1);
2427
2428 if (highlight)
2429 fprintf(stderr, HIGHLIGHT);
2430
2431 printf("%3u %-27s %-3s %-3s %-3s %-11s 0x%02x%02x%02x%02x%02x%02x %-7s %-7s %-4s %-4s\n",
2432 a->id,
2433 print_name(name, sizeof(name), a->id, a->name),
2434 a->current_value_valid ? tc : "n/a",
2435 a->worst_value_valid ? tw : "n/a",
2436 a->threshold_valid ? tt : "n/a",
2437 print_value(pretty, sizeof(pretty), a->pretty_value, a->pretty_unit),
2438 a->raw[0], a->raw[1], a->raw[2], a->raw[3], a->raw[4], a->raw[5],
2439 a->prefailure ? "prefail" : "old-age",
2440 a->online ? "online" : "offline",
2441 a->good_now_valid ? yes_no(a->good_now) : "n/a",
2442 a->good_in_the_past_valid ? yes_no(a->good_in_the_past) : "n/a");
2443
2444 if (highlight)
2445 fprintf(stderr, ENDHIGHLIGHT);
2446 }
2447
2448 int sk_disk_dump(SkDisk *d) {
2449 int ret;
2450 SkBool awake = FALSE;
2451 uint64_t size;
2452
2453 assert(d);
2454
2455 printf("Device: %s%s%s\n"
2456 "Type: %s\n",
2457 d->name ? disk_type_to_prefix_string(d->type) : "",
2458 d->name ? ":" : "",
2459 d->name ? d->name : "n/a",
2460 disk_type_to_human_string(d->type));
2461
2462 ret = sk_disk_get_size(d, &size);
2463 if (ret >= 0)
2464 printf("Size: %lu MiB\n", (unsigned long) (d->size/1024/1024));
2465 else
2466 printf("Size: %s\n", strerror(errno));
2467
2468 if (d->identify_valid) {
2469 const SkIdentifyParsedData *ipd;
2470 SkSmartQuirk quirk = 0;
2471 unsigned i;
2472
2473 if ((ret = sk_disk_identify_parse(d, &ipd)) < 0)
2474 return ret;
2475
2476 printf("Model: [%s]\n"
2477 "Serial: [%s]\n"
2478 "Firmware: [%s]\n"
2479 "SMART Available: %s\n",
2480 ipd->model,
2481 ipd->serial,
2482 ipd->firmware,
2483 yes_no(disk_smart_is_available(d)));
2484
2485 if ((ret = lookup_quirks(ipd->model, ipd->firmware, &quirk)))
2486 return ret;
2487
2488 printf("Quirks:");
2489
2490 for (i = 0; quirk_name[i]; i++)
2491 if (quirk & (1<<i))
2492 printf(" %s", _P(quirk_name[i]));
2493
2494 printf("\n");
2495 }
2496
2497 ret = sk_disk_check_sleep_mode(d, &awake);
2498 printf("Awake: %s\n",
2499 ret >= 0 ? yes_no(awake) : strerror(errno));
2500
2501 if (disk_smart_is_available(d)) {
2502 SkSmartOverall overall;
2503 const SkSmartParsedData *spd;
2504 SkBool good;
2505 char pretty[32];
2506 uint64_t value, power_on;
2507
2508 ret = sk_disk_smart_status(d, &good);
2509 printf("%sSMART Disk Health Good: %s%s\n",
2510 ret >= 0 && !good ? HIGHLIGHT : "",
2511 ret >= 0 ? yes_no(good) : strerror(errno),
2512 ret >= 0 && !good ? ENDHIGHLIGHT : "");
2513 if ((ret = sk_disk_smart_read_data(d)) < 0)
2514 return ret;
2515
2516 if ((ret = sk_disk_smart_parse(d, &spd)) < 0)
2517 return ret;
2518
2519 printf("Off-line Data Collection Status: [%s]\n"
2520 "Total Time To Complete Off-Line Data Collection: %u s\n"
2521 "Self-Test Execution Status: [%s]\n"
2522 "Percent Self-Test Remaining: %u%%\n"
2523 "Conveyance Self-Test Available: %s\n"
2524 "Short/Extended Self-Test Available: %s\n"
2525 "Start Self-Test Available: %s\n"
2526 "Abort Self-Test Available: %s\n"
2527 "Short Self-Test Polling Time: %u min\n"
2528 "Extended Self-Test Polling Time: %u min\n"
2529 "Conveyance Self-Test Polling Time: %u min\n",
2530 sk_smart_offline_data_collection_status_to_string(spd->offline_data_collection_status),
2531 spd->total_offline_data_collection_seconds,
2532 sk_smart_self_test_execution_status_to_string(spd->self_test_execution_status),
2533 spd->self_test_execution_percent_remaining,
2534 yes_no(spd->conveyance_test_available),
2535 yes_no(spd->short_and_extended_test_available),
2536 yes_no(spd->start_test_available),
2537 yes_no(spd->abort_test_available),
2538 spd->short_test_polling_minutes,
2539 spd->extended_test_polling_minutes,
2540 spd->conveyance_test_polling_minutes);
2541
2542 if (sk_disk_smart_get_bad(d, &value) < 0)
2543 printf("Bad Sectors: %s\n", strerror(errno));
2544 else
2545 printf("%sBad Sectors: %s%s\n",
2546 value > 0 ? HIGHLIGHT : "",
2547 print_value(pretty, sizeof(pretty), value, SK_SMART_ATTRIBUTE_UNIT_SECTORS),
2548 value > 0 ? ENDHIGHLIGHT : "");
2549
2550 if (sk_disk_smart_get_power_on(d, &power_on) < 0) {
2551 printf("Powered On: %s\n", strerror(errno));
2552 power_on = 0;
2553 } else
2554 printf("Powered On: %s\n", print_value(pretty, sizeof(pretty), power_on, SK_SMART_ATTRIBUTE_UNIT_MSECONDS));
2555
2556 if (sk_disk_smart_get_power_cycle(d, &value) < 0)
2557 printf("Power Cycles: %s\n", strerror(errno));
2558 else {
2559 printf("Power Cycles: %llu\n", (unsigned long long) value);
2560
2561 if (value > 0 && power_on > 0)
2562 printf("Average Powered On Per Power Cycle: %s\n", print_value(pretty, sizeof(pretty), power_on/value, SK_SMART_ATTRIBUTE_UNIT_MSECONDS));
2563 }
2564
2565 if (sk_disk_smart_get_temperature(d, &value) < 0)
2566 printf("Temperature: %s\n", strerror(errno));
2567 else
2568 printf("Temperature: %s\n", print_value(pretty, sizeof(pretty), value, SK_SMART_ATTRIBUTE_UNIT_MKELVIN));
2569
2570 printf("Attribute Parsing Verification: %s\n",
2571 d->attribute_verification_bad ? "Bad" : "Good");
2572
2573 if (sk_disk_smart_get_overall(d, &overall) < 0)
2574 printf("Overall Status: %s\n", strerror(errno));
2575 else
2576 printf("%sOverall Status: %s%s\n",
2577 overall != SK_SMART_OVERALL_GOOD ? HIGHLIGHT : "",
2578 sk_smart_overall_to_string(overall),
2579 overall != SK_SMART_OVERALL_GOOD ? ENDHIGHLIGHT : "");
2580
2581 printf("%3s %-27s %5s %5s %5s %-11s %-14s %-7s %-7s %-4s %-4s\n",
2582 "ID#",
2583 "Name",
2584 "Value",
2585 "Worst",
2586 "Thres",
2587 "Pretty",
2588 "Raw",
2589 "Type",
2590 "Updates",
2591 "Good",
2592 "Good/Past");
2593
2594 if ((ret = sk_disk_smart_parse_attributes(d, disk_dump_attributes, NULL)) < 0)
2595 return ret;
2596 } else
2597 printf("ATA SMART not supported.\n");
2598
2599 return 0;
2600 }
2601
2602 int sk_disk_get_size(SkDisk *d, uint64_t *bytes) {
2603 assert(d);
2604 assert(bytes);
2605
2606 if (d->size == (uint64_t) -1) {
2607 errno = ENODATA;
2608 return -1;
2609 }
2610
2611 *bytes = d->size;
2612 return 0;
2613 }
2614
2615 static int disk_find_type(SkDisk *d, dev_t devnum) {
2616 struct udev *udev;
2617 struct udev_device *dev = NULL, *usb;
2618 int r = -1;
2619 const char *a;
2620
2621 assert(d);
2622
2623 if (!(udev = udev_new())) {
2624 errno = ENXIO;
2625 goto finish;
2626 }
2627
2628 if (!(dev = udev_device_new_from_devnum(udev, 'b', devnum))) {
2629 errno = ENODEV;
2630 goto finish;
2631 }
2632
2633 if ((a = udev_device_get_property_value(dev, "ID_ATA_SMART_ACCESS"))) {
2634 unsigned u;
2635
2636 for (u = 0; u < _SK_DISK_TYPE_MAX; u++) {
2637 const char *t;
2638
2639 if (!(t = disk_type_to_prefix_string(u)))
2640 continue;
2641
2642 if (!strcmp(a, t)) {
2643 d->type = u;
2644 r = 0;
2645 goto finish;
2646 }
2647 }
2648
2649 d->type = SK_DISK_TYPE_NONE;
2650 r = 0;
2651 goto finish;
2652 }
2653
2654 if ((usb = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device"))) {
2655 const char *product, *vendor;
2656 uint32_t pid, vid;
2657
2658 if (!(product = udev_device_get_sysattr_value(usb, "idProduct")) ||
2659 sscanf(product, "%04x", &pid) != 1) {
2660 errno = ENODEV;
2661 goto finish;
2662 }
2663
2664 if (!(vendor = udev_device_get_sysattr_value(usb, "idVendor")) ||
2665 sscanf(vendor, "%04x", &vid) != 1) {
2666 errno = ENODEV;
2667 goto finish;
2668 }
2669
2670 if ((vid == 0x0928 && pid == 0x0000))
2671 /* This Oxford Semiconductor bridge seems to
2672 * choke on SAT commands. Let's explicitly
2673 * black list it here.
2674 *
2675 * http://bugs.freedesktop.org/show_bug.cgi?id=24951 */
2676 d->type = SK_DISK_TYPE_NONE;
2677 else if ((vid == 0x152d && pid == 0x2329) ||
2678 (vid == 0x152d && pid == 0x2338) ||
2679 (vid == 0x152d && pid == 0x2339))
2680 /* Some JMicron bridges seem to choke on SMART
2681 * commands, so let's explicitly black list
2682 * them here.
2683 *
2684 * https://bugzilla.redhat.com/show_bug.cgi?id=515881
2685 *
2686 * At least some of the JMicron bridges with
2687 * these vids/pids choke on the jmicron access
2688 * mode. To make sure we don't break things
2689 * for people we now disable this by
2690 * default. */
2691 d->type = SK_DISK_TYPE_NONE;
2692 else if ((vid == 0x152d && pid == 0x2336))
2693 /* This JMicron bridge seems to always work
2694 * with SMART commands send with the jmicron
2695 * access mode. */
2696 d->type = SK_DISK_TYPE_JMICRON;
2697 else if ((vid == 0x0c0b && pid == 0xb159) ||
2698 (vid == 0x04fc && pid == 0x0c25) ||
2699 (vid == 0x04fc && pid == 0x0c15))
2700 d->type = SK_DISK_TYPE_SUNPLUS;
2701 else
2702 d->type = SK_DISK_TYPE_ATA_PASSTHROUGH_12;
2703
2704 } else if (udev_device_get_parent_with_subsystem_devtype(dev, "ide", NULL))
2705 d->type = SK_DISK_TYPE_LINUX_IDE;
2706 else if (udev_device_get_parent_with_subsystem_devtype(dev, "scsi", NULL))
2707 d->type = SK_DISK_TYPE_ATA_PASSTHROUGH_16;
2708 else
2709 d->type = SK_DISK_TYPE_AUTO;
2710
2711 r = 0;
2712
2713 finish:
2714 if (dev)
2715 udev_device_unref(dev);
2716
2717 if (udev)
2718 udev_unref(udev);
2719
2720 return r;
2721 }
2722
2723 static int init_smart(SkDisk *d) {
2724 /* We don't do the SMART initialization right-away, since some
2725 * drivers spin up when we do that */
2726
2727 int ret;
2728
2729 if (d->smart_initialized)
2730 return 0;
2731
2732 d->smart_initialized = TRUE;
2733
2734 /* Check if driver can do SMART, and enable if necessary */
2735 if (!disk_smart_is_available(d))
2736 return 0;
2737
2738 if (!disk_smart_is_enabled(d)) {
2739 if ((ret = disk_smart_enable(d, TRUE)) < 0)
2740 goto fail;
2741
2742 if ((ret = disk_identify_device(d)) < 0)
2743 goto fail;
2744
2745 if (!disk_smart_is_enabled(d)) {
2746 errno = EIO;
2747 ret = -1;
2748 goto fail;
2749 }
2750 }
2751
2752 disk_smart_read_thresholds(d);
2753 ret = 0;
2754
2755 fail:
2756 return ret;
2757 }
2758
2759 int sk_disk_open(const char *name, SkDisk **_d) {
2760 SkDisk *d;
2761 int ret = -1;
2762 struct stat st;
2763
2764 assert(_d);
2765
2766 if (!(d = calloc(1, sizeof(SkDisk)))) {
2767 errno = ENOMEM;
2768 goto fail;
2769 }
2770
2771 d->fd = -1;
2772 d->size = (uint64_t) -1;
2773
2774 if (!name)
2775 d->type = SK_DISK_TYPE_BLOB;
2776 else {
2777 const char *dn;
2778
2779 d->type = SK_DISK_TYPE_AUTO;
2780
2781 if (!(dn = disk_type_from_string(name, &d->type)))
2782 dn = name;
2783
2784 if (!(d->name = strdup(dn))) {
2785 errno = ENOMEM;
2786 goto fail;
2787 }
2788
2789 if ((d->fd = open(d->name,
2790 O_RDONLY|O_NOCTTY|O_NONBLOCK
2791 #ifdef O_CLOEXEC
2792 |O_CLOEXEC
2793 #endif
2794
2795 )) < 0) {
2796 ret = d->fd;
2797 goto fail;
2798 }
2799
2800 if ((ret = fstat(d->fd, &st)) < 0)
2801 goto fail;
2802
2803 if (!S_ISBLK(st.st_mode)) {
2804 errno = ENODEV;
2805 ret = -1;
2806 goto fail;
2807 }
2808
2809 /* So, it's a block device. Let's make sure the ioctls work */
2810 if ((ret = ioctl(d->fd, BLKGETSIZE64, &d->size)) < 0)
2811 goto fail;
2812
2813 if (d->size <= 0 || d->size == (uint64_t) -1) {
2814 errno = EIO;
2815 ret = -1;
2816 goto fail;
2817 }
2818
2819 /* OK, it's a real block device with a size. Now let's find the suitable API */
2820 if (d->type == SK_DISK_TYPE_AUTO)
2821 if ((ret = disk_find_type(d, st.st_rdev)) < 0)
2822 goto fail;
2823
2824 if (d->type == SK_DISK_TYPE_AUTO) {
2825 /* We have no clue, so let's autotest for a working API */
2826 for (d->type = 0; d->type < _SK_DISK_TYPE_TEST_MAX; d->type++)
2827 if (disk_identify_device(d) >= 0)
2828 break;
2829 if (d->type >= _SK_DISK_TYPE_TEST_MAX)
2830 d->type = SK_DISK_TYPE_NONE;
2831 } else
2832 disk_identify_device(d);
2833 }
2834
2835 *_d = d;
2836
2837 return 0;
2838
2839 fail:
2840
2841 if (d)
2842 sk_disk_free(d);
2843
2844 return ret;
2845 }
2846
2847 void sk_disk_free(SkDisk *d) {
2848 assert(d);
2849
2850 if (d->fd >= 0)
2851 close(d->fd);
2852
2853 free(d->name);
2854 free(d->blob);
2855 free(d);
2856 }
2857
2858 int sk_disk_get_blob(SkDisk *d, const void **blob, size_t *rsize) {
2859 size_t size;
2860 SkBool good, have_good = FALSE;
2861 uint32_t *p;
2862
2863 assert(d);
2864 assert(blob);
2865 assert(rsize);
2866
2867 size =
2868 (d->identify_valid ? 8 + sizeof(d->identify) : 0) +
2869 (d->smart_data_valid ? 8 + sizeof(d->smart_data) : 0) +
2870 (d->smart_thresholds_valid ? 8 + sizeof(d->smart_thresholds) : 0);
2871
2872 if (sk_disk_smart_status(d, &good) >= 0) {
2873 size += 12;
2874 have_good = TRUE;
2875 }
2876
2877 if (size <= 0) {
2878 errno = ENODATA;
2879 return -1;
2880 }
2881
2882 free(d->blob);
2883 if (!(d->blob = malloc(size))) {
2884 errno = ENOMEM;
2885 return -1;
2886 }
2887
2888 p = d->blob;
2889
2890 /* These memory accesses are only OK as long as all our
2891 * objects are sensibly aligned, which they are... */
2892
2893 if (d->identify_valid) {
2894 p[0] = SK_BLOB_TAG_IDENTIFY;
2895 p[1] = htonl(sizeof(d->identify));
2896 p += 2;
2897
2898 memcpy(p, d->identify, sizeof(d->identify));
2899 p = (uint32_t*) ((uint8_t*) p + sizeof(d->identify));
2900 }
2901
2902 if (have_good) {
2903 p[0] = SK_BLOB_TAG_SMART_STATUS;
2904 p[1] = htonl(4);
2905 p[2] = htonl(!!good);
2906 p += 3;
2907 }
2908
2909 if (d->smart_data_valid) {
2910 p[0] = SK_BLOB_TAG_SMART_DATA;
2911 p[1] = htonl(sizeof(d->smart_data));
2912 p += 2;
2913
2914 memcpy(p, d->smart_data, sizeof(d->smart_data));
2915 p = (uint32_t*) ((uint8_t*) p + sizeof(d->smart_data));
2916 }
2917
2918 if (d->smart_thresholds_valid) {
2919 p[0] = SK_BLOB_TAG_SMART_THRESHOLDS;
2920 p[1] = htonl(sizeof(d->smart_thresholds));
2921 p += 2;
2922
2923 memcpy(p, d->smart_thresholds, sizeof(d->smart_thresholds));
2924 p = (uint32_t*) ((uint8_t*) p + sizeof(d->smart_thresholds));
2925 }
2926
2927 assert((size_t) ((uint8_t*) p - (uint8_t*) d->blob) == size);
2928
2929 *blob = d->blob;
2930 *rsize = size;
2931
2932 return 0;
2933 }
2934
2935 int sk_disk_set_blob(SkDisk *d, const void *blob, size_t size) {
2936 const uint32_t *p;
2937 size_t left;
2938 SkBool idv = FALSE, sdv = FALSE, stv = FALSE, bssv = FALSE;
2939
2940 assert(d);
2941 assert(blob);
2942
2943 if (d->type != SK_DISK_TYPE_BLOB) {
2944 errno = ENODEV;
2945 return -1;
2946 }
2947
2948 if (size <= 0) {
2949 errno = EINVAL;
2950 return -1;
2951 }
2952
2953 /* First run, verify if everything makes sense */
2954 p = blob;
2955 left = size;
2956 while (left > 0) {
2957 uint32_t tag, tsize;
2958
2959 if (left < 8) {
2960 errno = EINVAL;
2961 return -1;
2962 }
2963
2964 memcpy(&tag, p, 4);
2965 memcpy(&tsize, p+1, 4);
2966 p += 2;
2967 left -= 8;
2968
2969 if (left < ntohl(tsize)) {
2970 errno = EINVAL;
2971 return -1;
2972 }
2973
2974 switch (tag) {
2975
2976 case SK_BLOB_TAG_IDENTIFY:
2977 if (ntohl(tsize) != sizeof(d->identify) || idv) {
2978 errno = EINVAL;
2979 return -1;
2980 }
2981 idv = TRUE;
2982 break;
2983
2984 case SK_BLOB_TAG_SMART_STATUS:
2985 if (ntohl(tsize) != 4 || bssv) {
2986 errno = EINVAL;
2987 return -1;
2988 }
2989 bssv = TRUE;
2990 break;
2991
2992 case SK_BLOB_TAG_SMART_DATA:
2993 if (ntohl(tsize) != sizeof(d->smart_data) || sdv) {
2994 errno = EINVAL;
2995 return -1;
2996 }
2997 sdv = TRUE;
2998 break;
2999
3000 case SK_BLOB_TAG_SMART_THRESHOLDS:
3001 if (ntohl(tsize) != sizeof(d->smart_thresholds) || stv) {
3002 errno = EINVAL;
3003 return -1;
3004 }
3005 stv = TRUE;
3006 break;
3007 }
3008
3009 p = (uint32_t*) ((uint8_t*) p + ntohl(tsize));
3010 left -= ntohl(tsize);
3011 }
3012
3013 if (!idv) {
3014 errno = -ENODATA;
3015 return -1;
3016 }
3017
3018 d->identify_valid = idv;
3019 d->smart_data_valid = sdv;
3020 d->smart_thresholds_valid = stv;
3021 d->blob_smart_status_valid = bssv;
3022
3023 /* Second run, actually copy things in */
3024 p = blob;
3025 left = size;
3026 while (left > 0) {
3027 uint32_t tag, tsize;
3028
3029 assert(left >= 8);
3030 memcpy(&tag, p, 4);
3031 memcpy(&tsize, p+1, 4);
3032 p += 2;
3033 left -= 8;
3034
3035 assert(left >= ntohl(tsize));
3036
3037 switch (tag) {
3038
3039 case SK_BLOB_TAG_IDENTIFY:
3040 assert(ntohl(tsize) == sizeof(d->identify));
3041 memcpy(d->identify, p, sizeof(d->identify));
3042 break;
3043
3044 case SK_BLOB_TAG_SMART_STATUS: {
3045 uint32_t ok;
3046 assert(ntohl(tsize) == 4);
3047 memcpy(&ok, p, 4);
3048 d->blob_smart_status = !!ok;
3049 break;
3050 }
3051
3052 case SK_BLOB_TAG_SMART_DATA:
3053 assert(ntohl(tsize) == sizeof(d->smart_data));
3054 memcpy(d->smart_data, p, sizeof(d->smart_data));
3055 break;
3056
3057 case SK_BLOB_TAG_SMART_THRESHOLDS:
3058 assert(ntohl(tsize) == sizeof(d->smart_thresholds));
3059 memcpy(d->smart_thresholds, p, sizeof(d->smart_thresholds));
3060 break;
3061 }
3062
3063 p = (uint32_t*) ((uint8_t*) p + ntohl(tsize));
3064 left -= ntohl(tsize);
3065 }
3066
3067 return 0;
3068 }