atasmart.c

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