os_netbsd.cpp

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