os_solaris.cpp

   1 /*
   2  * os_solaris.c
   3  *
   4  * Home page of code is: http://smartmontools.sourceforge.net
   5  *
   6  * Copyright (C) 2003-6 SAWADA Keiji <smartmontools-support@lists.sourceforge.net>
   7  * Copyright (C) 2003-6 Casper Dik <smartmontools-support@lists.sourceforge.net>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * (for example COPYING); if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21 #include <ctype.h>
  22 #include <string.h>
  23 #include <dirent.h>
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <sys/param.h>
  27
  28 // These are needed to define prototypes for the functions defined below
  29 #include "config.h"
  30 #include "int64.h"
  31 #include "atacmds.h"
  32 #include "scsicmds.h"
  33 #include "utility.h"
  34
  35 // This is to include whatever prototypes you define in os_solaris.h
  36 #include "os_solaris.h"
  37
  38 #define ARGUSED(x) ((void)(x))
  39
  40 extern long long bytes;
  41
  42 static const char *filenameandversion="$Id: os_solaris.cpp,v 1.28 2006/08/25 06:06:25 sxzzsf Exp $";
  43
  44 const char *os_XXXX_c_cvsid="$Id: os_solaris.cpp,v 1.28 2006/08/25 06:06:25 sxzzsf Exp $" \
  45 ATACMDS_H_CVSID CONFIG_H_CVSID INT64_H_CVSID OS_SOLARIS_H_CVSID SCSICMDS_H_CVSID UTILITY_H_CVSID;
  46
  47 // The printwarning() function warns about unimplemented functions
  48 int printedout[2];
  49 char *unimplemented[2]={
  50   "ATA command routine ata_command_interface()",
  51   "3ware Escalade Controller command routine escalade_command_interface()",
  52 };
  53
  54 int printwarning(int which){
  55   if (!unimplemented[which])
  56     return 0;
  57
  58   if (printedout[which])
  59     return 1;
  60
  61   printedout[which]=1;
  62
  63   pout("\n"
  64        "#######################################################################\n"
  65        "%s NOT IMPLEMENTED under Solaris.\n"
  66        "Please contact " PACKAGE_BUGREPORT " if\n"
  67        "you want to help in porting smartmontools to Solaris.\n"
  68        "#######################################################################\n"
  69        "\n",
  70        unimplemented[which]);
  71
  72   return 1;
  73 }
  74
  75 // print examples for smartctl
  76 void print_smartctl_examples(){
  77   printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
  78 #ifdef HAVE_GETOPT_LONG
  79   printf(
  80          "  smartctl -a /dev/rdsk/c0t0d0s0             (Prints all SMART information)\n\n"
  81          "  smartctl --smart=on --offlineauto=on --saveauto=on /dev/rdsk/c0t0d0s0\n"
  82          "                                              (Enables SMART on first disk)\n\n"
  83          "  smartctl -t long /dev/rdsk/c0t0d0s0 (Executes extended disk self-test)\n\n"
  84          "  smartctl --attributes --log=selftest --quietmode=errorsonly /dev/rdsk/c0t0d0s0\n"
  85          "                                      (Prints Self-Test & Attribute errors)\n"
  86          );
  87 #else
  88   printf(
  89          "  smartctl -a /dev/rdsk/c0t0d0s0               (Prints all SMART information)\n"
  90          "  smartctl -s on -o on -S on /dev/rdsk/c0t0d0s0 (Enables SMART on first disk)\n"
  91          "  smartctl -t long /dev/rdsk/c0t0d0s0      (Executes extended disk self-test)\n"
  92          "  smartctl -A -l selftest -q errorsonly /dev/rdsk/c0t0d0s0\n"
  93          "                                        (Prints Self-Test & Attribute errors)\n"
  94          );
  95 #endif
  96   return;
  97 }
  98
  99 static const char *uscsidrvrs[] = {
 100         "sd",
 101         "ssd",
 102         "st"
 103 };
 104
 105 static const char *atadrvrs[] = {
 106         "cmdk",
 107         "dad",
 108 };
 109
 110 static int
 111 isdevtype(const char *dev_name, const char *table[], int tsize)
 112 {
 113   char devpath[MAXPATHLEN];
 114   int i;
 115   char *basename;
 116
 117   if (realpath(dev_name, devpath) == NULL)
 118     return 0;
 119
 120   if ((basename = strrchr(devpath, '/')) == NULL)
 121     return 0;
 122
 123   basename++;
 124
 125   for (i = 0; i < tsize; i++) {
 126     int l = strlen(table[i]);
 127     if (strncmp(basename, table[i], l) == 0 && basename[l] == '@')
 128       return 1;
 129   }
 130   return 0;
 131 }
 132
 133 static int
 134 isscsidev(const char *path)
 135 {
 136   return isdevtype(path, uscsidrvrs, sizeof (uscsidrvrs) / sizeof (char *));
 137 }
 138
 139 static int
 140 isatadev(const char *path)
 141 {
 142   return isdevtype(path, atadrvrs, sizeof (atadrvrs) / sizeof (char *));
 143 }
 144
 145 // tries to guess device type given the name (a path)
 146 int guess_device_type (const char* dev_name) {
 147   if (isscsidev(dev_name))
 148     return CONTROLLER_SCSI;
 149   else if (isatadev(dev_name))
 150     return CONTROLLER_ATA;
 151   else
 152     return CONTROLLER_UNKNOWN;
 153 }
 154
 155 struct pathlist {
 156         char **names;
 157         int  nnames;
 158         int  maxnames;
 159 };
 160
 161 static int
 162 addpath(const char *path, struct pathlist *res)
 163 {
 164         if (++res->nnames > res->maxnames) {
 165                 res->maxnames += 16;
 166                 res->names = static_cast<char**>(realloc(res->names, res->maxnames * sizeof (char *)));
 167                 if (res->names == NULL)
 168                         return -1;
 169                 bytes += 16*sizeof(char *);
 170         }
 171         if (!(res->names[res->nnames-1] = CustomStrDup((char *)path, 1, __LINE__, filenameandversion)))
 172                 return -1;
 173         return 0;
 174 }
 175
 176 static int
 177 grokdir(const char *dir, struct pathlist *res, int testfun(const char *))
 178 {
 179         char pathbuf[MAXPATHLEN];
 180         size_t len;
 181         DIR *dp;
 182         struct dirent *de;
 183         int isdisk = strstr(dir, "dsk") != NULL;
 184         char *p;
 185
 186         len = snprintf(pathbuf, sizeof (pathbuf), "%s/", dir);
 187         if (len >= sizeof (pathbuf))
 188                 return -1;
 189
 190         dp = opendir(dir);
 191         if (dp == NULL)
 192                 return 0;
 193
 194         while ((de = readdir(dp)) != NULL) {
 195                 if (de->d_name[0] == '.')
 196                         continue;
 197
 198                 if (strlen(de->d_name) + len >= sizeof (pathbuf))
 199                         continue;
 200
 201                 if (isdisk) {
 202                         /* Disk represented by slice 0 */
 203                         p = strstr(de->d_name, "s0");
 204                         /* String doesn't end in "s0\0" */
 205                         if (p == NULL || p[2] != '\0')
 206                                 continue;
 207                 } else {
 208                         /* Tape drive represented by the all-digit device */
 209                         for (p = de->d_name; *p; p++)
 210                                 if (!isdigit((int)(*p)))
 211                                         break;
 212                         if (*p != '\0')
 213                                 continue;
 214                 }
 215                 strcpy(&pathbuf[len], de->d_name);
 216                 if (testfun(pathbuf)) {
 217                         if (addpath(pathbuf, res) == -1) {
 218                                 closedir(dp);
 219                                 return -1;
 220                         }
 221                 }
 222         }
 223         closedir(dp);
 224
 225         return 0;
 226 }
 227
 228 // makes a list of ATA or SCSI devices for the DEVICESCAN directive of
 229 // smartd.  Returns number of devices, or -1 if out of memory.
 230 int make_device_names (char*** devlist, const char* name) {
 231         struct pathlist res;
 232
 233         res.nnames = res.maxnames = 0;
 234         res.names = NULL;
 235         if (strcmp(name, "SCSI") == 0) {
 236                 if (grokdir("/dev/rdsk", &res, isscsidev) == -1)
 237                         return -1;
 238                 if (grokdir("/dev/rmt", &res, isscsidev) == -1)
 239                         return -1;
 240         } else if (strcmp(name, "ATA") == 0) {
 241                 if (grokdir("/dev/rdsk", &res, isatadev) == -1)
 242                         return -1;
 243         } else {
 244                 // non-SCSI and non-ATA case not implemented
 245                 *devlist=NULL;
 246                 return 0;
 247         }
 248
 249         // shrink array to min possible size
 250         res.names = static_cast<char**>(realloc(res.names, res.nnames * sizeof (char *)));
 251         bytes -= sizeof(char *)*(res.maxnames-res.nnames);
 252
 253         // pass list back
 254         *devlist = res.names;
 255         return res.nnames;
 256 }
 257
 258 // Like open().  Return integer handle, used by functions below only.
 259 // type="ATA" or "SCSI".
 260 int deviceopen(const char *pathname, char *type){
 261   if (!strcmp(type,"SCSI"))
 262     return open(pathname, O_RDWR | O_NONBLOCK);
 263   else if (!strcmp(type,"ATA"))
 264     return open(pathname, O_RDONLY | O_NONBLOCK);
 265   else
 266     return -1;
 267 }
 268
 269 // Like close().  Acts on handles returned by above function.
 270 int deviceclose(int fd){
 271     return close(fd);
 272 }
 273
 274 #if defined(__sparc)
 275 // swap each 2-byte pairs in a sector
 276 static void swap_sector(void *p)
 277 {
 278     int i;
 279     char t, *cp = static_cast<char*>(p);
 280     for(i = 0; i < 256; i++) {
 281         t = cp[0]; cp[0] = cp[1]; cp[1] = t;
 282         cp += 2;
 283     }
 284 }
 285 #endif
 286
 287 // Interface to ATA devices.  See os_linux.c
 288 int marvell_command_interface(int fd, smart_command_set command, int select, char *data){
 289     ARGUSED(fd); ARGUSED(command); ARGUSED(select); ARGUSED(data);
 290     return -1;
 291 }
 292
 293 int highpoint_command_interface(int fd, smart_command_set command, int select, char *data)
 294 {
 295     ARGUSED(fd); ARGUSED(command); ARGUSED(select); ARGUSED(data);
 296     return -1;
 297 }
 298
 299 int ata_command_interface(int fd, smart_command_set command, int select, char *data){
 300 #if defined(__sparc)
 301     int err;
 302
 303     switch (command){
 304     case CHECK_POWER_MODE:
 305         /* currently not recognized */
 306         return -1;
 307     case READ_VALUES:
 308         return smart_read_data(fd, data);
 309     case READ_THRESHOLDS:
 310         return smart_read_thresholds(fd, data);
 311     case READ_LOG:
 312         return smart_read_log(fd, select, 1, data);
 313     case IDENTIFY:
 314         err = ata_identify(fd, data);
 315         if(err) return err;
 316         swap_sector(static_cast<void*>(data));
 317         return 0;
 318     case PIDENTIFY:
 319         err = ata_pidentify(fd, data);
 320         if(err) return err;
 321         swap_sector(static_cast<void*>(data));
 322         return 0;
 323     case ENABLE:
 324         return smart_enable(fd);
 325     case DISABLE:
 326         return smart_disable(fd);
 327     case STATUS:
 328         return smart_status(fd);
 329     case AUTO_OFFLINE:
 330         return smart_auto_offline(fd, select);
 331     case AUTOSAVE:
 332         return smart_auto_save(fd, select);
 333     case IMMEDIATE_OFFLINE:
 334         return smart_immediate_offline(fd, select);
 335     case STATUS_CHECK:
 336         return smart_status_check(fd);
 337     default:
 338         pout("Unrecognized command %d in ata_command_interface() of os_solaris.c\n", command);
 339         exit(1);
 340         break;
 341     }
 342 #else /* __sparc */
 343     ARGUSED(fd); ARGUSED(command); ARGUSED(select); ARGUSED(data);
 344
 345     /* Above smart_* routines uses undocumented ioctls of "dada"
 346      * driver, which is specific to SPARC Solaris.  See
 347      * os_solaris_ata.s for further details. x86 Solaris seems not to
 348      * provide similar or alternative interface... */
 349     if (printwarning(0))
 350         return -1;
 351 #endif
 352     return -1;
 353 }
 354
 355 // Interface to ATA devices behind 3ware escalade RAID controller cards.  See os_linux.c
 356 int escalade_command_interface(int fd, int disknum, int escalade_type, smart_command_set command, int select, char *data){
 357   ARGUSED(fd);  ARGUSED(disknum);  ARGUSED(escalade_type);
 358   ARGUSED(command);  ARGUSED(select);  ARGUSED(data);
 359
 360   if (printwarning(1))
 361     return -1;
 362   return -1;
 363 }
 364
 365 #include <errno.h>
 366 #include <sys/scsi/generic/commands.h>
 367 #include <sys/scsi/generic/status.h>
 368 #include <sys/scsi/impl/types.h>
 369 #include <sys/scsi/impl/uscsi.h>
 370
 371 // Interface to SCSI devices.  See os_linux.c
 372 int do_scsi_cmnd_io(int fd, struct scsi_cmnd_io * iop, int report) {
 373   struct uscsi_cmd uscsi;
 374
 375     if (report > 0) {
 376         int k;
 377         const unsigned char * ucp = iop->cmnd;
 378         const char * np;
 379
 380         np = scsi_get_opcode_name(ucp[0]);
 381         pout(" [%s: ", np ? np : "<unknown opcode>");
 382         for (k = 0; k < (int)iop->cmnd_len; ++k)
 383             pout("%02x ", ucp[k]);
 384         if ((report > 1) &&
 385             (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
 386             int trunc = (iop->dxfer_len > 256) ? 1 : 0;
 387
 388             pout("]\n  Outgoing data, len=%d%s:\n", (int)iop->dxfer_len,
 389                  (trunc ? " [only first 256 bytes shown]" : ""));
 390             dStrHex((char *)iop->dxferp, (trunc ? 256 : iop->dxfer_len) , 1);
 391         }
 392         else
 393             pout("]");
 394     }
 395
 396
 397   memset(&uscsi, 0, sizeof (uscsi));
 398
 399   uscsi.uscsi_cdb = reinterpret_cast<char*>(iop->cmnd);
 400   uscsi.uscsi_cdblen = iop->cmnd_len;
 401   if (iop->timeout == 0)
 402     uscsi.uscsi_timeout = 60; /* XXX */
 403   else
 404     uscsi.uscsi_timeout = iop->timeout;
 405   uscsi.uscsi_bufaddr = reinterpret_cast<char*>(iop->dxferp);
 406   uscsi.uscsi_buflen = iop->dxfer_len;
 407   uscsi.uscsi_rqbuf = reinterpret_cast<char*>(iop->sensep);
 408   uscsi.uscsi_rqlen = iop->max_sense_len;
 409
 410   switch (iop->dxfer_dir) {
 411   case DXFER_NONE:
 412   case DXFER_FROM_DEVICE:
 413     uscsi.uscsi_flags = USCSI_READ;
 414     break;
 415   case DXFER_TO_DEVICE:
 416     uscsi.uscsi_flags = USCSI_WRITE;
 417     break;
 418   default:
 419     return -EINVAL;
 420   }
 421   uscsi.uscsi_flags |= USCSI_ISOLATE;
 422
 423   if (ioctl(fd, USCSICMD, &uscsi))
 424     return -errno;
 425
 426   iop->scsi_status = uscsi.uscsi_status;
 427   iop->resid = uscsi.uscsi_resid;
 428   iop->resp_sense_len = iop->max_sense_len - uscsi.uscsi_rqresid;
 429
 430   if (report > 0) {
 431     int trunc = (iop->dxfer_len > 256) ? 1 : 0;
 432     pout("  status=0\n");
 433
 434     pout("  Incoming data, len=%d%s:\n", (int)iop->dxfer_len,
 435          (trunc ? " [only first 256 bytes shown]" : ""));
 436     dStrHex((char *)iop->dxferp, (trunc ? 256 : iop->dxfer_len) , 1);
 437   }
 438
 439   return (0);
 440 }