[mirror_smartmontools-debian.git] / os_netbsd.cpp

/*
 * os_netbsd.cpp
 *
 * Home page of code is: http://smartmontools.sourceforge.net
 *
 * Copyright (C) 2003-8 Sergey Svishchev <smartmontools-support@lists.sourceforge.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * You should have received a copy of the GNU General Public License
 * (for example COPYING); if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include "config.h"
#include "int64.h"
#include "atacmds.h"
#include "scsicmds.h"
#include "utility.h"
#include "os_netbsd.h"
#include <unistd.h>

const char *os_XXXX_c_cvsid = "$Id: os_netbsd.cpp,v 1.25 2008/06/12 21:46:31 ballen4705 Exp $" \
ATACMDS_H_CVSID CONFIG_H_CVSID INT64_H_CVSID OS_NETBSD_H_CVSID SCSICMDS_H_CVSID UTILITY_H_CVSID;

/* global variable holding byte count of allocated memory */
extern long long bytes;

enum warnings {
  BAD_SMART, NO_3WARE, NO_ARECA, MAX_MSG
};

/* Utility function for printing warnings */
void
printwarning(int msgNo, const char *extra)
{
  static int printed[] = {0, 0};
  static const char *message[] = {
    "Error: SMART Status command failed.\nPlease get assistance from \n" PACKAGE_HOMEPAGE "\nRegister values returned from SMART Status command are:\n",
    PACKAGE_STRING " does not currently support twe(4) and twa(4) devices (3ware Escalade, Apache)\n",
  };

  if (msgNo >= 0 && msgNo <= MAX_MSG) {
    if (!printed[msgNo]) {
      printed[msgNo] = 1;
      pout("%s", message[msgNo]);
      if (extra)
	pout("%s", extra);
    }
  }
  return;
}

static const char *net_dev_prefix = "/dev/";
static const char *net_dev_ata_disk = "wd";
static const char *net_dev_scsi_disk = "sd";
static const char *net_dev_scsi_tape = "enrst";

/* Guess device type (ATA or SCSI) based on device name */
int
guess_device_type(const char *dev_name)
{
  int len;
  int dev_prefix_len = strlen(net_dev_prefix);

  if (!dev_name || !(len = strlen(dev_name)))
    return CONTROLLER_UNKNOWN;

  if (!strncmp(net_dev_prefix, dev_name, dev_prefix_len)) {
    if (len <= dev_prefix_len)
      return CONTROLLER_UNKNOWN;
    else
      dev_name += dev_prefix_len;
  }
  if (!strncmp(net_dev_ata_disk, dev_name, strlen(net_dev_ata_disk)))
    return CONTROLLER_ATA;

  if (!strncmp(net_dev_scsi_disk, dev_name, strlen(net_dev_scsi_disk)))
    return CONTROLLER_SCSI;

  if (!strncmp(net_dev_scsi_tape, dev_name, strlen(net_dev_scsi_tape)))
    return CONTROLLER_SCSI;

  return CONTROLLER_UNKNOWN;
}

int
get_dev_names(char ***names, const char *prefix)
{
  char *disknames, *p, **mp;
  int n = 0;
  int sysctl_mib[2];
  size_t sysctl_len;

  *names = NULL;

  sysctl_mib[0] = CTL_HW;
  sysctl_mib[1] = HW_DISKNAMES;
  if (-1 == sysctl(sysctl_mib, 2, NULL, &sysctl_len, NULL, 0)) {
    pout("Failed to get value of sysctl `hw.disknames'\n");
    return -1;
  }
  if (!(disknames = (char *)malloc(sysctl_len))) {
    pout("Out of memory constructing scan device list\n");
    return -1;
  }
  if (-1 == sysctl(sysctl_mib, 2, disknames, &sysctl_len, NULL, 0)) {
    pout("Failed to get value of sysctl `hw.disknames'\n");
    return -1;
  }
  if (!(mp = (char **) calloc(strlen(disknames) / 2, sizeof(char *)))) {
    pout("Out of memory constructing scan device list\n");
    return -1;
  }
  for (p = strtok(disknames, " "); p; p = strtok(NULL, " ")) {
    if (strncmp(p, prefix, strlen(prefix))) {
      continue;
    }
    mp[n] = (char *)malloc(strlen(net_dev_prefix) + strlen(p) + 2);
    if (!mp[n]) {
      pout("Out of memory constructing scan device list\n");
      return -1;
    }
    sprintf(mp[n], "%s%s%c", net_dev_prefix, p, 'a' + getrawpartition());
    bytes += strlen(mp[n]) + 1;
    n++;
  }

  mp = (char **)realloc(mp, n * (sizeof(char *)));
  bytes += (n) * (sizeof(char *));
  *names = mp;
  return n;
}

int
make_device_names(char ***devlist, const char *name)
{
  if (!strcmp(name, "SCSI"))
    return get_dev_names(devlist, net_dev_scsi_disk);
  else if (!strcmp(name, "ATA"))
    return get_dev_names(devlist, net_dev_ata_disk);
  else
    return 0;
}

int
deviceopen(const char *pathname, char *type)
{
  if (!strcmp(type, "SCSI")) {
    int fd = open(pathname, O_RDWR | O_NONBLOCK);
    if (fd < 0 && errno == EROFS)
      fd = open(pathname, O_RDONLY | O_NONBLOCK);
    return fd;
  } else if (!strcmp(type, "ATA"))
    return open(pathname, O_RDWR | O_NONBLOCK);
  else
    return -1;
}

int
deviceclose(int fd)
{
  return close(fd);
}

int
marvell_command_interface(int fd, smart_command_set command, int select, char *data)
{ return -1; }

int
highpoint_command_interface(int fd, smart_command_set command, int select, char *data)
{ return -1; }

int
ata_command_interface(int fd, smart_command_set command, int select, char *data)
{
  struct atareq req;
  unsigned char inbuf[DEV_BSIZE];
  int retval, copydata = 0;

  memset(&req, 0, sizeof(req));
  req.timeout = 1000;

  memset(&inbuf, 0, sizeof(inbuf));

  switch (command) {
  case READ_VALUES:
    req.flags = ATACMD_READ;
    req.features = WDSM_RD_DATA;
    req.command = WDCC_SMART;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    req.cylinder = WDSMART_CYL;
    copydata = 1;
    break;
  case READ_THRESHOLDS:
    req.flags = ATACMD_READ;
    req.features = WDSM_RD_THRESHOLDS;
    req.command = WDCC_SMART;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    req.cylinder = WDSMART_CYL;
    copydata = 1;
    break;
  case READ_LOG:
    req.flags = ATACMD_READ;
    req.features = ATA_SMART_READ_LOG_SECTOR;	/* XXX missing from wdcreg.h */
    req.command = WDCC_SMART;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    req.cylinder = WDSMART_CYL;
    req.sec_num = select;
    req.sec_count = 1;
    copydata = 1;
    break;
  case WRITE_LOG:
    memcpy(inbuf, data, 512);
    req.flags = ATACMD_WRITE;
    req.features = ATA_SMART_WRITE_LOG_SECTOR;	/* XXX missing from wdcreg.h */
    req.command = WDCC_SMART;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    req.cylinder = WDSMART_CYL;
    req.sec_num = select;
    req.sec_count = 1;
    break;
  case IDENTIFY:
    req.flags = ATACMD_READ;
    req.command = WDCC_IDENTIFY;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    copydata = 1;
    break;
  case PIDENTIFY:
    req.flags = ATACMD_READ;
    req.command = ATAPI_IDENTIFY_DEVICE;
    req.databuf = (char *)inbuf;
    req.datalen = sizeof(inbuf);
    copydata = 1;
    break;
  case ENABLE:
    req.flags = ATACMD_READREG;
    req.features = WDSM_ENABLE_OPS;
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    break;
  case DISABLE:
    req.flags = ATACMD_READREG;
    req.features = WDSM_DISABLE_OPS;
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    break;
  case AUTO_OFFLINE:
    /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
    req.flags = ATACMD_READREG;
    req.features = ATA_SMART_AUTO_OFFLINE;	/* XXX missing from wdcreg.h */
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    req.sec_count = select;
    break;
  case AUTOSAVE:
    req.flags = ATACMD_READREG;
    req.features = ATA_SMART_AUTOSAVE;	/* XXX missing from wdcreg.h */
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    req.sec_count = select;
    break;
  case IMMEDIATE_OFFLINE:
    /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
    req.flags = ATACMD_READREG;
    req.features = ATA_SMART_IMMEDIATE_OFFLINE;	/* XXX missing from wdcreg.h */
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    req.sec_num = select;
    req.sec_count = 1;
    break;
  case STATUS:		/* should return 0 if SMART is enabled at all */
  case STATUS_CHECK:	/* should return 0 if disk's health is ok */
    req.flags = ATACMD_READREG;
    req.features = WDSM_STATUS;
    req.command = WDCC_SMART;
    req.cylinder = WDSMART_CYL;
    break;
  case CHECK_POWER_MODE:
    req.flags = ATACMD_READREG;
    req.command = WDCC_CHECK_PWR;
    break;
  default:
    pout("Unrecognized command %d in ata_command_interface()\n", command);
    errno = ENOSYS;
    return -1;
  }

  if (command == STATUS_CHECK || command == AUTOSAVE || command == AUTO_OFFLINE) {
    char buf[512];

    unsigned const short normal = WDSMART_CYL, failed = 0x2cf4;

    if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
      perror("Failed command");
      return -1;
    }
    if (req.retsts != ATACMD_OK) {
      return -1;
    }
    /* Cyl low and Cyl high unchanged means "Good SMART status" */
    if (req.cylinder == normal)
      return 0;

    /* These values mean "Bad SMART status" */
    if (req.cylinder == failed)
      return 1;

    /* We haven't gotten output that makes sense; 
     * print out some debugging info */
    snprintf(buf, sizeof(buf),
      "CMD=0x%02x\nFR =0x%02x\nNS =0x%02x\nSC =0x%02x\nCL =0x%02x\nCH =0x%02x\nRETURN =0x%04x\n",
      (int) req.command, (int) req.features, (int) req.sec_count, (int) req.sec_num,
      (int) (le16toh(req.cylinder) & 0xff), (int) ((le16toh(req.cylinder) >> 8) & 0xff),
      (int) req.error);
    printwarning(BAD_SMART, buf);
    return 0;
  }

  if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
    perror("Failed command");
    return -1;
  }
  if (req.retsts != ATACMD_OK) {
    return -1;
  }

  if (command == CHECK_POWER_MODE)
    data[0] = req.sec_count;

  if (copydata)
    memcpy(data, inbuf, 512);

  return 0;
}

int
escalade_command_interface(int fd, int disknum, int escalade_type, smart_command_set command, int select, char *data)
{
  printwarning(NO_3WARE, NULL);
  return -1;
}

int
areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data)
{
  printwarning(NO_ARECA, NULL);
  return -1;
}

int
do_scsi_cmnd_io(int fd, struct scsi_cmnd_io * iop, int report)
{
  struct scsireq sc;

  if (report > 0) {
    size_t k;

    const unsigned char *ucp = iop->cmnd;
    const char *np;

    np = scsi_get_opcode_name(ucp[0]);
    pout(" [%s: ", np ? np : "<unknown opcode>");
    for (k = 0; k < iop->cmnd_len; ++k)
      pout("%02x ", ucp[k]);
    if ((report > 1) &&
      (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
      int trunc = (iop->dxfer_len > 256) ? 1 : 0;

      pout("]\n  Outgoing data, len=%d%s:\n", (int) iop->dxfer_len,
	(trunc ? " [only first 256 bytes shown]" : ""));
      dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
    } else
      pout("]");
  }
  memset(&sc, 0, sizeof(sc));
  memcpy(sc.cmd, iop->cmnd, iop->cmnd_len);
  sc.cmdlen = iop->cmnd_len;
  sc.databuf = (char *)iop->dxferp;
  sc.datalen = iop->dxfer_len;
  sc.senselen = iop->max_sense_len;
  sc.timeout = iop->timeout == 0 ? 60000 : (1000 * iop->timeout);
  sc.flags =
    (iop->dxfer_dir == DXFER_NONE ? SCCMD_READ :
    (iop->dxfer_dir == DXFER_FROM_DEVICE ? SCCMD_READ : SCCMD_WRITE));

  if (ioctl(fd, SCIOCCOMMAND, &sc) < 0) {
    warn("error sending SCSI ccb");
    return -1;
  }
  iop->resid = sc.datalen - sc.datalen_used;
  iop->scsi_status = sc.status;
  if (iop->sensep) {
    memcpy(iop->sensep, sc.sense, sc.senselen_used);
    iop->resp_sense_len = sc.senselen_used;
  }
  if (report > 0) {
    int trunc;

    pout("  status=0\n");
    trunc = (iop->dxfer_len > 256) ? 1 : 0;

    pout("  Incoming data, len=%d%s:\n", (int) iop->dxfer_len,
      (trunc ? " [only first 256 bytes shown]" : ""));
    dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
  }
  switch (sc.retsts) {
    case SCCMD_OK:
      return 0;
    case SCCMD_TIMEOUT:
      return -ETIMEDOUT;
    case SCCMD_BUSY:
      return -EBUSY;
    default:
      return -EIO;
  }
}

/* print examples for smartctl */
void 
print_smartctl_examples()
{
  char p;

  p = 'a' + getrawpartition();
  printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
#ifdef HAVE_GETOPT_LONG
  printf(
    "  smartctl -a /dev/wd0%c                      (Prints all SMART information)\n\n"
    "  smartctl --smart=on --offlineauto=on --saveauto=on /dev/wd0%c\n"
    "                                              (Enables SMART on first disk)\n\n"
    "  smartctl -t long /dev/wd0%c             (Executes extended disk self-test)\n\n"
    "  smartctl --attributes --log=selftest --quietmode=errorsonly /dev/wd0%c\n"
    "                                      (Prints Self-Test & Attribute errors)\n",
    p, p, p, p
    );
#else
  printf(
    "  smartctl -a /dev/wd0%c                     (Prints all SMART information)\n"
    "  smartctl -s on -o on -S on /dev/wd0%c        (Enables SMART on first disk)\n"
    "  smartctl -t long /dev/wd0%c            (Executes extended disk self-test)\n"
    "  smartctl -A -l selftest -q errorsonly /dev/wd0%c"
    "                                      (Prints Self-Test & Attribute errors)\n",
    p, p, p, p
    );
#endif
  return;
}
Commit	Line	Data
832b75ed	1	/*
4d59bff9	2	* os_netbsd.cpp
832b75ed GG	3	*
	4	* Home page of code is: http://smartmontools.sourceforge.net
	5	*
34ad0c5f	6	* Copyright (C) 2003-8 Sergey Svishchev <smartmontools-support@lists.sourceforge.net>
832b75ed GG	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
2127e193	27	const char *os_XXXX_c_cvsid = "$Id: os_netbsd.cpp,v 1.25 2008/06/12 21:46:31 ballen4705 Exp $" \
832b75ed GG	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 {
2127e193	34	BAD_SMART, NO_3WARE, NO_ARECA, MAX_MSG
832b75ed GG	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",
34ad0c5f	44	PACKAGE_STRING " does not currently support twe(4) and twa(4) devices (3ware Escalade, Apache)\n",
832b75ed GG	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
34ad0c5f	63	/* Guess device type (ATA or SCSI) based on device name */
832b75ed GG	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	}
4d59bff9	107	if (!(disknames = (char *)malloc(sysctl_len))) {
832b75ed GG	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	}
4d59bff9	123	mp[n] = (char *)malloc(strlen(net_dev_prefix) + strlen(p) + 2);
832b75ed GG	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
4d59bff9	133	mp = (char *)realloc(mp, n (sizeof(char *)));
832b75ed GG	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
34ad0c5f GG	174	int
	175	highpoint_command_interface(int fd, smart_command_set command, int select, char *data)
	176	{ return -1; }
4d59bff9	177
832b75ed GG	178	int
	179	ata_command_interface(int fd, smart_command_set command, int select, char *data)
	180	{
	181	struct atareq req;
	182	unsigned char inbuf[DEV_BSIZE];
	183	int retval, copydata = 0;
	184
	185	memset(&req, 0, sizeof(req));
34ad0c5f GG	186	req.timeout = 1000;
34ad0c5f GG	187
832b75ed GG	188	memset(&inbuf, 0, sizeof(inbuf));
	189
	190	switch (command) {
	191	case READ_VALUES:
	192	req.flags = ATACMD_READ;
	193	req.features = WDSM_RD_DATA;
	194	req.command = WDCC_SMART;
4d59bff9	195	req.databuf = (char *)inbuf;
832b75ed GG	196	req.datalen = sizeof(inbuf);
832b75ed GG	197	req.cylinder = WDSMART_CYL;
832b75ed GG	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;
4d59bff9	204	req.databuf = (char *)inbuf;
832b75ed GG	205	req.datalen = sizeof(inbuf);
832b75ed GG	206	req.cylinder = WDSMART_CYL;
832b75ed GG	207	copydata = 1;
	208	break;
	209	case READ_LOG:
	210	req.flags = ATACMD_READ;
	211	req.features = ATA_SMART_READ_LOG_SECTOR; /* XXX missing from wdcreg.h */
	212	req.command = WDCC_SMART;
4d59bff9	213	req.databuf = (char *)inbuf;
832b75ed GG	214	req.datalen = sizeof(inbuf);
	215	req.cylinder = WDSMART_CYL;
	216	req.sec_num = select;
	217	req.sec_count = 1;
832b75ed GG	218	copydata = 1;
	219	break;
	220	case WRITE_LOG:
	221	memcpy(inbuf, data, 512);
	222	req.flags = ATACMD_WRITE;
	223	req.features = ATA_SMART_WRITE_LOG_SECTOR; /* XXX missing from wdcreg.h */
	224	req.command = WDCC_SMART;
4d59bff9	225	req.databuf = (char *)inbuf;
832b75ed GG	226	req.datalen = sizeof(inbuf);
	227	req.cylinder = WDSMART_CYL;
	228	req.sec_num = select;
	229	req.sec_count = 1;
832b75ed GG	230	break;
	231	case IDENTIFY:
	232	req.flags = ATACMD_READ;
	233	req.command = WDCC_IDENTIFY;
4d59bff9	234	req.databuf = (char *)inbuf;
832b75ed	235	req.datalen = sizeof(inbuf);
832b75ed GG	236	copydata = 1;
	237	break;
	238	case PIDENTIFY:
	239	req.flags = ATACMD_READ;
	240	req.command = ATAPI_IDENTIFY_DEVICE;
4d59bff9	241	req.databuf = (char *)inbuf;
832b75ed	242	req.datalen = sizeof(inbuf);
832b75ed GG	243	copydata = 1;
	244	break;
	245	case ENABLE:
34ad0c5f	246	req.flags = ATACMD_READREG;
832b75ed GG	247	req.features = WDSM_ENABLE_OPS;
	248	req.command = WDCC_SMART;
	249	req.cylinder = WDSMART_CYL;
832b75ed GG	250	break;
832b75ed GG	251	case DISABLE:
34ad0c5f	252	req.flags = ATACMD_READREG;
832b75ed GG	253	req.features = WDSM_DISABLE_OPS;
	254	req.command = WDCC_SMART;
	255	req.cylinder = WDSMART_CYL;
832b75ed GG	256	break;
	257	case AUTO_OFFLINE:
	258	/* NOTE: According to ATAPI 4 and UP, this command is obsolete */
34ad0c5f	259	req.flags = ATACMD_READREG;
832b75ed GG	260	req.features = ATA_SMART_AUTO_OFFLINE; /* XXX missing from wdcreg.h */
832b75ed GG	261	req.command = WDCC_SMART;
832b75ed	262	req.cylinder = WDSMART_CYL;
34ad0c5f	263	req.sec_count = select;
832b75ed GG	264	break;
832b75ed GG	265	case AUTOSAVE:
34ad0c5f	266	req.flags = ATACMD_READREG;
832b75ed GG	267	req.features = ATA_SMART_AUTOSAVE; /* XXX missing from wdcreg.h */
	268	req.command = WDCC_SMART;
	269	req.cylinder = WDSMART_CYL;
34ad0c5f	270	req.sec_count = select;
832b75ed GG	271	break;
	272	case IMMEDIATE_OFFLINE:
	273	/* NOTE: According to ATAPI 4 and UP, this command is obsolete */
34ad0c5f	274	req.flags = ATACMD_READREG;
832b75ed GG	275	req.features = ATA_SMART_IMMEDIATE_OFFLINE; /* XXX missing from wdcreg.h */
832b75ed GG	276	req.command = WDCC_SMART;
832b75ed GG	277	req.cylinder = WDSMART_CYL;
	278	req.sec_num = select;
	279	req.sec_count = 1;
832b75ed	280	break;
34ad0c5f GG	281	case STATUS: /* should return 0 if SMART is enabled at all */
	282	case STATUS_CHECK: /* should return 0 if disk's health is ok */
	283	req.flags = ATACMD_READREG;
832b75ed GG	284	req.features = WDSM_STATUS;
	285	req.command = WDCC_SMART;
	286	req.cylinder = WDSMART_CYL;
832b75ed GG	287	break;
	288	case CHECK_POWER_MODE:
	289	req.flags = ATACMD_READREG;
	290	req.command = WDCC_CHECK_PWR;
832b75ed GG	291	break;
	292	default:
	293	pout("Unrecognized command %d in ata_command_interface()\n", command);
	294	errno = ENOSYS;
	295	return -1;
	296	}
	297
34ad0c5f	298	if (command == STATUS_CHECK \|\| command == AUTOSAVE \|\| command == AUTO_OFFLINE) {
832b75ed GG	299	char buf[512];
	300
	301	unsigned const short normal = WDSMART_CYL, failed = 0x2cf4;
	302
	303	if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
	304	perror("Failed command");
	305	return -1;
	306	}
34ad0c5f GG	307	if (req.retsts != ATACMD_OK) {
	308	return -1;
	309	}
832b75ed GG	310	/* Cyl low and Cyl high unchanged means "Good SMART status" */
	311	if (req.cylinder == normal)
	312	return 0;
	313
	314	/* These values mean "Bad SMART status" */
	315	if (req.cylinder == failed)
	316	return 1;
	317
	318	/* We haven't gotten output that makes sense;
	319	* print out some debugging info */
	320	snprintf(buf, sizeof(buf),
	321	"CMD=0x%02x\nFR =0x%02x\nNS =0x%02x\nSC =0x%02x\nCL =0x%02x\nCH =0x%02x\nRETURN =0x%04x\n",
	322	(int) req.command, (int) req.features, (int) req.sec_count, (int) req.sec_num,
	323	(int) (le16toh(req.cylinder) & 0xff), (int) ((le16toh(req.cylinder) >> 8) & 0xff),
	324	(int) req.error);
	325	printwarning(BAD_SMART, buf);
	326	return 0;
	327	}
34ad0c5f	328
832b75ed GG	329	if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
	330	perror("Failed command");
	331	return -1;
	332	}
34ad0c5f GG	333	if (req.retsts != ATACMD_OK) {
	334	return -1;
	335	}
	336
832b75ed GG	337	if (command == CHECK_POWER_MODE)
	338	data[0] = req.sec_count;
	339
	340	if (copydata)
	341	memcpy(data, inbuf, 512);
	342
	343	return 0;
	344	}
	345
	346	int
	347	escalade_command_interface(int fd, int disknum, int escalade_type, smart_command_set command, int select, char *data)
	348	{
	349	printwarning(NO_3WARE, NULL);
	350	return -1;
	351	}
	352
2127e193 GI	353	int
	354	areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data)
	355	{
	356	printwarning(NO_ARECA, NULL);
	357	return -1;
	358	}
	359
832b75ed GG	360	int
	361	do_scsi_cmnd_io(int fd, struct scsi_cmnd_io * iop, int report)
	362	{
	363	struct scsireq sc;
	364
	365	if (report > 0) {
	366	size_t k;
	367
	368	const unsigned char *ucp = iop->cmnd;
	369	const char *np;
	370
	371	np = scsi_get_opcode_name(ucp[0]);
	372	pout(" [%s: ", np ? np : "<unknown opcode>");
	373	for (k = 0; k < iop->cmnd_len; ++k)
	374	pout("%02x ", ucp[k]);
	375	if ((report > 1) &&
	376	(DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
	377	int trunc = (iop->dxfer_len > 256) ? 1 : 0;
	378
	379	pout("]\n Outgoing data, len=%d%s:\n", (int) iop->dxfer_len,
	380	(trunc ? " [only first 256 bytes shown]" : ""));
	381	dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
	382	} else
	383	pout("]");
	384	}
	385	memset(&sc, 0, sizeof(sc));
	386	memcpy(sc.cmd, iop->cmnd, iop->cmnd_len);
	387	sc.cmdlen = iop->cmnd_len;
4d59bff9	388	sc.databuf = (char *)iop->dxferp;
832b75ed GG	389	sc.datalen = iop->dxfer_len;
	390	sc.senselen = iop->max_sense_len;
	391	sc.timeout = iop->timeout == 0 ? 60000 : (1000 * iop->timeout);
	392	sc.flags =
4d59bff9	393	(iop->dxfer_dir == DXFER_NONE ? SCCMD_READ :
832b75ed GG	394	(iop->dxfer_dir == DXFER_FROM_DEVICE ? SCCMD_READ : SCCMD_WRITE));
	395
	396	if (ioctl(fd, SCIOCCOMMAND, &sc) < 0) {
	397	warn("error sending SCSI ccb");
	398	return -1;
	399	}
	400	iop->resid = sc.datalen - sc.datalen_used;
	401	iop->scsi_status = sc.status;
	402	if (iop->sensep) {
	403	memcpy(iop->sensep, sc.sense, sc.senselen_used);
	404	iop->resp_sense_len = sc.senselen_used;
	405	}
	406	if (report > 0) {
	407	int trunc;
	408
	409	pout(" status=0\n");
	410	trunc = (iop->dxfer_len > 256) ? 1 : 0;
	411
	412	pout(" Incoming data, len=%d%s:\n", (int) iop->dxfer_len,
	413	(trunc ? " [only first 256 bytes shown]" : ""));
	414	dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
	415	}
34ad0c5f GG	416	switch (sc.retsts) {
	417	case SCCMD_OK:
	418	return 0;
	419	case SCCMD_TIMEOUT:
	420	return -ETIMEDOUT;
	421	case SCCMD_BUSY:
	422	return -EBUSY;
	423	default:
	424	return -EIO;
	425	}
832b75ed GG	426	}
	427
	428	/* print examples for smartctl */
	429	void
	430	print_smartctl_examples()
	431	{
	432	char p;
	433
	434	p = 'a' + getrawpartition();
	435	printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
	436	#ifdef HAVE_GETOPT_LONG
	437	printf(
	438	" smartctl -a /dev/wd0%c (Prints all SMART information)\n\n"
	439	" smartctl --smart=on --offlineauto=on --saveauto=on /dev/wd0%c\n"
	440	" (Enables SMART on first disk)\n\n"
	441	" smartctl -t long /dev/wd0%c (Executes extended disk self-test)\n\n"
	442	" smartctl --attributes --log=selftest --quietmode=errorsonly /dev/wd0%c\n"
	443	" (Prints Self-Test & Attribute errors)\n",
	444	p, p, p, p
	445	);
	446	#else
	447	printf(
	448	" smartctl -a /dev/wd0%c (Prints all SMART information)\n"
	449	" smartctl -s on -o on -S on /dev/wd0%c (Enables SMART on first disk)\n"
	450	" smartctl -t long /dev/wd0%c (Executes extended disk self-test)\n"
	451	" smartctl -A -l selftest -q errorsonly /dev/wd0%c"
	452	" (Prints Self-Test & Attribute errors)\n",
	453	p, p, p, p
	454	);
	455	#endif
	456	return;
	457	}