os_openbsd.cpp

   1 /*
   2  * os_openbsd.c
   3  *
   4  * Home page of code is: http://smartmontools.sourceforge.net
   5  *
   6  * Copyright (C) 2004-6 David Snyder <smartmontools-support@lists.sourceforge.net>
   7  *
   8  * Derived from os_netbsd.cpp by Sergey Svishchev <smartmontools-support@lists.sourceforge.net>, Copyright (C) 2003-6
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2, or (at your option)
  13  * any later version.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * (for example COPYING); if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "int64.h"
  23 #include "atacmds.h"
  24 #include "scsicmds.h"
  25 #include "utility.h"
  26 #include "os_openbsd.h"
  27
  28 const char *os_XXXX_c_cvsid = "$Id: os_openbsd.cpp,v 1.14 2007/04/05 16:39:21 shattered Exp $" \
  29 ATACMDS_H_CVSID CONFIG_H_CVSID INT64_H_CVSID OS_OPENBSD_H_CVSID SCSICMDS_H_CVSID UTILITY_H_CVSID;
  30
  31 /* global variable holding byte count of allocated memory */
  32 extern long long bytes;
  33
  34 enum warnings {
  35   BAD_SMART, NO_3WARE, MAX_MSG
  36 };
  37
  38 /* Utility function for printing warnings */
  39 void
  40 printwarning(int msgNo, const char *extra)
  41 {
  42   static int printed[] = {0, 0};
  43   static const char *message[] = {
  44     "Error: SMART Status command failed.\nPlease get assistance from \n" PACKAGE_HOMEPAGE "\nRegister values returned from SMART Status command are:\n",
  45     PACKAGE_STRING " does not currentlly support twe(4) devices (3ware Escalade)\n",
  46   };
  47
  48   if (msgNo >= 0 && msgNo <= MAX_MSG) {
  49     if (!printed[msgNo]) {
  50       printed[msgNo] = 1;
  51       pout("%s", message[msgNo]);
  52       if (extra)
  53         pout("%s", extra);
  54     }
  55   }
  56   return;
  57 }
  58
  59 static const char *net_dev_prefix = "/dev/";
  60 static const char *net_dev_ata_disk = "wd";
  61 static const char *net_dev_scsi_disk = "sd";
  62 static const char *net_dev_scsi_tape = "st";
  63
  64 /* Guess device type(ata or scsi) based on device name */
  65 int
  66 guess_device_type(const char *dev_name)
  67 {
  68   int len;
  69   int dev_prefix_len = strlen(net_dev_prefix);
  70
  71   if (!dev_name || !(len = strlen(dev_name)))
  72     return CONTROLLER_UNKNOWN;
  73
  74   if (!strncmp(net_dev_prefix, dev_name, dev_prefix_len)) {
  75     if (len <= dev_prefix_len)
  76       return CONTROLLER_UNKNOWN;
  77     else
  78       dev_name += dev_prefix_len;
  79   }
  80   if (!strncmp(net_dev_ata_disk, dev_name, strlen(net_dev_ata_disk)))
  81     return CONTROLLER_ATA;
  82
  83   if (!strncmp(net_dev_scsi_disk, dev_name, strlen(net_dev_scsi_disk)))
  84     return CONTROLLER_SCSI;
  85
  86   if (!strncmp(net_dev_scsi_tape, dev_name, strlen(net_dev_scsi_tape)))
  87     return CONTROLLER_SCSI;
  88
  89   return CONTROLLER_UNKNOWN;
  90 }
  91
  92 int
  93 get_dev_names(char ***names, const char *prefix)
  94 {
  95   char *disknames, *p, **mp;
  96   int n = 0;
  97   int sysctl_mib[2];
  98   size_t sysctl_len;
  99
 100   *names = NULL;
 101
 102   sysctl_mib[0] = CTL_HW;
 103   sysctl_mib[1] = HW_DISKNAMES;
 104   if (-1 == sysctl(sysctl_mib, 2, NULL, &sysctl_len, NULL, 0)) {
 105     pout("Failed to get value of sysctl `hw.disknames'\n");
 106     return -1;
 107   }
 108   if (!(disknames = (char *)malloc(sysctl_len))) {
 109     pout("Out of memory constructing scan device list\n");
 110     return -1;
 111   }
 112   if (-1 == sysctl(sysctl_mib, 2, disknames, &sysctl_len, NULL, 0)) {
 113     pout("Failed to get value of sysctl `hw.disknames'\n");
 114     return -1;
 115   }
 116   if (!(mp = (char **) calloc(strlen(disknames) / 2, sizeof(char *)))) {
 117     pout("Out of memory constructing scan device list\n");
 118     return -1;
 119   }
 120   for (p = strtok(disknames, ","); p; p = strtok(NULL, ",")) {
 121     if (strncmp(p, prefix, strlen(prefix))) {
 122       continue;
 123     }
 124     mp[n] = (char *)malloc(strlen(net_dev_prefix) + strlen(p) + 2);
 125     if (!mp[n]) {
 126       pout("Out of memory constructing scan device list\n");
 127       return -1;
 128     }
 129     sprintf(mp[n], "%s%s%c", net_dev_prefix, p, 'a' + getrawpartition());
 130     bytes += strlen(mp[n]) + 1;
 131     n++;
 132   }
 133
 134   mp = (char **)realloc(mp, n * (sizeof(char *)));
 135   bytes += (n) * (sizeof(char *));
 136   *names = mp;
 137   return n;
 138 }
 139
 140 int
 141 make_device_names(char ***devlist, const char *name)
 142 {
 143   if (!strcmp(name, "SCSI"))
 144     return get_dev_names(devlist, net_dev_scsi_disk);
 145   else if (!strcmp(name, "ATA"))
 146     return get_dev_names(devlist, net_dev_ata_disk);
 147   else
 148     return 0;
 149 }
 150
 151 int
 152 deviceopen(const char *pathname, char *type)
 153 {
 154   if (!strcmp(type, "SCSI")) {
 155     int fd = open(pathname, O_RDWR | O_NONBLOCK);
 156     if (fd < 0 && errno == EROFS)
 157       fd = open(pathname, O_RDONLY | O_NONBLOCK);
 158     return fd;
 159   } else if (!strcmp(type, "ATA"))
 160     return open(pathname, O_RDWR | O_NONBLOCK);
 161   else
 162     return -1;
 163 }
 164
 165 int
 166 deviceclose(int fd)
 167 {
 168   return close(fd);
 169 }
 170
 171 int
 172 marvell_command_interface(int fd, smart_command_set command, int select, char *data)
 173 { return -1; }
 174
 175 int highpoint_command_interface(int fd, smart_command_set command, int select, char *data)
 176 {
 177   return -1;
 178 }
 179
 180 int
 181 ata_command_interface(int fd, smart_command_set command, int select, char *data)
 182 {
 183   struct atareq req;
 184   unsigned char inbuf[DEV_BSIZE];
 185   int retval, copydata = 0;
 186
 187   memset(&req, 0, sizeof(req));
 188   memset(&inbuf, 0, sizeof(inbuf));
 189
 190   switch (command) {
 191   case READ_VALUES:
 192     req.flags = ATACMD_READ;
 193     req.features = ATA_SMART_READ_VALUES;
 194     req.command = ATAPI_SMART;
 195     req.databuf = (caddr_t) inbuf;
 196     req.datalen = sizeof(inbuf);
 197     req.cylinder = htole16(WDSMART_CYL);
 198     req.timeout = 1000;
 199     copydata = 1;
 200     break;
 201   case READ_THRESHOLDS:
 202     req.flags = ATACMD_READ;
 203     req.features = ATA_SMART_READ_THRESHOLDS;
 204     req.command = ATAPI_SMART;
 205     req.databuf = (caddr_t) inbuf;
 206     req.datalen = sizeof(inbuf);
 207     req.cylinder = htole16(WDSMART_CYL);
 208     req.timeout = 1000;
 209     copydata = 1;
 210     break;
 211   case READ_LOG:
 212     req.flags = ATACMD_READ;
 213     req.features = ATA_SMART_READ_LOG_SECTOR;   /* XXX missing from wdcreg.h */
 214     req.command = ATAPI_SMART;
 215     req.databuf = (caddr_t) inbuf;
 216     req.datalen = sizeof(inbuf);
 217     req.cylinder = htole16(WDSMART_CYL);
 218     req.sec_num = select;
 219     req.sec_count = 1;
 220     req.timeout = 1000;
 221     copydata = 1;
 222     break;
 223   case WRITE_LOG:
 224     memcpy(inbuf, data, 512);
 225     req.flags = ATACMD_WRITE;
 226     req.features = ATA_SMART_WRITE_LOG_SECTOR;  /* XXX missing from wdcreg.h */
 227     req.command = ATAPI_SMART;
 228     req.databuf = (caddr_t) inbuf;
 229     req.datalen = sizeof(inbuf);
 230     req.cylinder = htole16(WDSMART_CYL);
 231     req.sec_num = select;
 232     req.sec_count = 1;
 233     req.timeout = 1000;
 234     break;
 235   case IDENTIFY:
 236     req.flags = ATACMD_READ;
 237     req.command = WDCC_IDENTIFY;
 238     req.databuf = (caddr_t) inbuf;
 239     req.datalen = sizeof(inbuf);
 240     req.timeout = 1000;
 241     copydata = 1;
 242     break;
 243   case PIDENTIFY:
 244     req.flags = ATACMD_READ;
 245     req.command = ATAPI_IDENTIFY_DEVICE;
 246     req.databuf = (caddr_t) inbuf;
 247     req.datalen = sizeof(inbuf);
 248     req.timeout = 1000;
 249     copydata = 1;
 250     break;
 251   case ENABLE:
 252     req.flags = ATACMD_READ;
 253     req.features = ATA_SMART_ENABLE;
 254     req.command = ATAPI_SMART;
 255     req.cylinder = htole16(WDSMART_CYL);
 256     req.timeout = 1000;
 257     break;
 258   case DISABLE:
 259     req.flags = ATACMD_READ;
 260     req.features = ATA_SMART_DISABLE;
 261     req.command = ATAPI_SMART;
 262     req.cylinder = htole16(WDSMART_CYL);
 263     req.timeout = 1000;
 264     break;
 265   case AUTO_OFFLINE:
 266     /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
 267     req.flags = ATACMD_READ;
 268     req.features = ATA_SMART_AUTO_OFFLINE;      /* XXX missing from wdcreg.h */
 269     req.command = ATAPI_SMART;
 270     req.databuf = (caddr_t) inbuf;
 271     req.datalen = sizeof(inbuf);
 272     req.cylinder = htole16(WDSMART_CYL);
 273     req.sec_num = select;
 274     req.sec_count = 1;
 275     req.timeout = 1000;
 276     break;
 277   case AUTOSAVE:
 278     req.flags = ATACMD_READ;
 279     req.features = ATA_SMART_AUTOSAVE;  /* XXX missing from wdcreg.h */
 280     req.command = ATAPI_SMART;
 281     req.cylinder = htole16(WDSMART_CYL);
 282     req.sec_count = 0xf1;
 283     /* to enable autosave */
 284     req.timeout = 1000;
 285     break;
 286   case IMMEDIATE_OFFLINE:
 287     /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
 288     req.flags = ATACMD_READ;
 289     req.features = ATA_SMART_IMMEDIATE_OFFLINE; /* XXX missing from wdcreg.h */
 290     req.command = ATAPI_SMART;
 291     req.databuf = (caddr_t) inbuf;
 292     req.datalen = sizeof(inbuf);
 293     req.cylinder = htole16(WDSMART_CYL);
 294     req.sec_num = select;
 295     req.sec_count = 1;
 296     req.timeout = 1000;
 297     break;
 298   case STATUS_CHECK:
 299     /* same command, no HDIO in NetBSD */
 300   case STATUS:
 301     req.flags = ATACMD_READ;
 302     req.features = ATA_SMART_STATUS;
 303     req.command = ATAPI_SMART;
 304     req.cylinder = htole16(WDSMART_CYL);
 305     req.timeout = 1000;
 306     break;
 307   case CHECK_POWER_MODE:
 308     req.flags = ATACMD_READREG;
 309     req.command = WDCC_CHECK_PWR;
 310     req.timeout = 1000;
 311     break;
 312   default:
 313     pout("Unrecognized command %d in ata_command_interface()\n", command);
 314     errno = ENOSYS;
 315     return -1;
 316   }
 317
 318   if (command == STATUS_CHECK) {
 319     char buf[512];
 320
 321     unsigned const short normal = WDSMART_CYL, failed = 0x2cf4;
 322
 323     if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
 324       perror("Failed command");
 325       return -1;
 326     }
 327     /* Cyl low and Cyl high unchanged means "Good SMART status" */
 328     if (letoh16(req.cylinder) == normal)
 329       return 0;
 330
 331     /* These values mean "Bad SMART status" */
 332     if (letoh16(req.cylinder) == failed)
 333       return 1;
 334
 335     /* We haven't gotten output that makes sense;
 336      * print out some debugging info */
 337     snprintf(buf, sizeof(buf),
 338       "CMD=0x%02x\nFR =0x%02x\nNS =0x%02x\nSC =0x%02x\nCL =0x%02x\nCH =0x%02x\nRETURN =0x%04x\n",
 339       (int) req.command, (int) req.features, (int) req.sec_count, (int) req.sec_num,
 340       (int) (letoh16(req.cylinder) & 0xff), (int) ((letoh16(req.cylinder) >> 8) & 0xff),
 341       (int) req.error);
 342     printwarning(BAD_SMART, buf);
 343     return 0;
 344   }
 345   if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
 346     perror("Failed command");
 347     return -1;
 348   }
 349   if (command == CHECK_POWER_MODE)
 350     data[0] = req.sec_count;
 351
 352   if (copydata)
 353     memcpy(data, inbuf, 512);
 354
 355   return 0;
 356 }
 357
 358 int
 359 escalade_command_interface(int fd, int disknum, int escalade_type, smart_command_set command, int select, char *data)
 360 {
 361   printwarning(NO_3WARE, NULL);
 362   return -1;
 363 }
 364
 365 int
 366 do_scsi_cmnd_io(int fd, struct scsi_cmnd_io * iop, int report)
 367 {
 368   struct scsireq sc;
 369
 370   if (report > 0) {
 371     size_t k;
 372
 373     const unsigned char *ucp = iop->cmnd;
 374     const char *np;
 375
 376     np = scsi_get_opcode_name(ucp[0]);
 377     pout(" [%s: ", np ? np : "<unknown opcode>");
 378     for (k = 0; k < iop->cmnd_len; ++k)
 379       pout("%02x ", ucp[k]);
 380     if ((report > 1) &&
 381       (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
 382       int trunc = (iop->dxfer_len > 256) ? 1 : 0;
 383
 384       pout("]\n  Outgoing data, len=%d%s:\n", (int) iop->dxfer_len,
 385         (trunc ? " [only first 256 bytes shown]" : ""));
 386       dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
 387     } else
 388       pout("]");
 389   }
 390   memset(&sc, 0, sizeof(sc));
 391   memcpy(sc.cmd, iop->cmnd, iop->cmnd_len);
 392   sc.cmdlen = iop->cmnd_len;
 393   sc.databuf = (char *)iop->dxferp;
 394   sc.datalen = iop->dxfer_len;
 395   sc.senselen = iop->max_sense_len;
 396   sc.timeout = iop->timeout == 0 ? 60000 : iop->timeout;        /* XXX */
 397   sc.flags =
 398     (iop->dxfer_dir == DXFER_NONE ? SCCMD_READ :
 399     (iop->dxfer_dir == DXFER_FROM_DEVICE ? SCCMD_READ : SCCMD_WRITE));
 400
 401   if (ioctl(fd, SCIOCCOMMAND, &sc) < 0) {
 402     warn("error sending SCSI ccb");
 403     return -1;
 404   }
 405   iop->resid = sc.datalen - sc.datalen_used;
 406   iop->scsi_status = sc.status;
 407   if (iop->sensep) {
 408     memcpy(iop->sensep, sc.sense, sc.senselen_used);
 409     iop->resp_sense_len = sc.senselen_used;
 410   }
 411   if (report > 0) {
 412     int trunc;
 413
 414     pout("  status=0\n");
 415     trunc = (iop->dxfer_len > 256) ? 1 : 0;
 416
 417     pout("  Incoming data, len=%d%s:\n", (int) iop->dxfer_len,
 418       (trunc ? " [only first 256 bytes shown]" : ""));
 419     dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
 420   }
 421   return 0;
 422 }
 423
 424 /* print examples for smartctl */
 425 void
 426 print_smartctl_examples()
 427 {
 428   char p;
 429
 430   p = 'a' + getrawpartition();
 431   printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
 432 #ifdef HAVE_GETOPT_LONG
 433   printf(
 434     "  smartctl -a /dev/wd0%c                      (Prints all SMART information)\n\n"
 435     "  smartctl --smart=on --offlineauto=on --saveauto=on /dev/wd0%c\n"
 436     "                                              (Enables SMART on first disk)\n\n"
 437     "  smartctl -t long /dev/wd0%c             (Executes extended disk self-test)\n\n"
 438     "  smartctl --attributes --log=selftest --quietmode=errorsonly /dev/wd0%c\n"
 439     "                                      (Prints Self-Test & Attribute errors)\n",
 440     p, p, p, p
 441     );
 442 #else
 443   printf(
 444     "  smartctl -a /dev/wd0%c                     (Prints all SMART information)\n"
 445     "  smartctl -s on -o on -S on /dev/wd0%c        (Enables SMART on first disk)\n"
 446     "  smartctl -t long /dev/wd0%c            (Executes extended disk self-test)\n"
 447     "  smartctl -A -l selftest -q errorsonly /dev/wd0%c"
 448     "                                      (Prints Self-Test & Attribute errors)\n",
 449     p, p, p, p
 450     );
 451 #endif
 452   return;
 453 }