File: [local] / src / sbin / atactl / atactl.c (download)
Revision 1.49, Sun Apr 30 00:58:38 2023 UTC (13 months, 1 week ago) by yasuoka
Branch: MAIN
CVS Tags: OPENBSD_7_5_BASE, OPENBSD_7_5, OPENBSD_7_4_BASE, OPENBSD_7_4, HEAD
Changes since 1.48: +6 -8 lines
Fix that atactl sd0 readattr didn't work for some disks. Change it to
check the cksums of the attribute values instead of comparing the
revisions. diff from NetBSD through naito.yuichiro at gmail.com. test
by kolipe.c at exoticsilicon.com.
ok kevlo miod deraadt
|
/* $OpenBSD: atactl.c,v 1.49 2023/04/30 00:58:38 yasuoka Exp $ */
/* $NetBSD: atactl.c,v 1.4 1999/02/24 18:49:14 jwise Exp $ */
/*-
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Ken Hornstein.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* atactl(8) - a program to control ATA devices.
*/
#include <sys/param.h> /* DEV_BSIZE */
#include <sys/ioctl.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>
#include <dev/ata/atareg.h>
#include <dev/ic/wdcreg.h>
#include <dev/ic/wdcevent.h>
#include <sys/ataio.h>
#include "atasec.h"
#include "atasmart.h"
struct command {
const char *cmd_name;
void (*cmd_func)(int, char *[]);
};
struct bitinfo {
u_int bitmask;
const char *string;
};
struct valinfo {
int value;
const char *string;
};
int main(int, char *[]);
__dead void usage(void);
void ata_command(struct atareq *);
void print_bitinfo(const char *, u_int, struct bitinfo *);
int strtoval(const char *, struct valinfo *);
const char *valtostr(int, struct valinfo *, const char *);
int fd; /* file descriptor for device */
extern char *__progname; /* from crt0.o */
void device_dump(int, char*[]);
void device_identify(int, char *[]);
void device_setidle(int, char *[]);
void device_idle(int, char *[]);
void device_checkpower(int, char *[]);
void device_acoustic(int, char *[]);
void device_apm(int, char *[]);
void device_feature(int, char *[]);
void device_sec_setpass(int, char *[]);
void device_sec_unlock(int, char *[]);
void device_sec_erase(int, char *[]);
void device_sec_freeze(int, char *[]);
void device_sec_disablepass(int, char *[]);
void device_smart_enable(int, char *[]);
void device_smart_disable(int, char *[]);
void device_smart_status(int, char *[]);
void device_smart_autosave(int, char *[]);
void device_smart_offline(int, char *[]);
void device_smart_read(int, char *[]);
void device_smart_readlog(int, char *[]);
void device_attr(int, char *[]);
void smart_print_errdata(struct smart_log_errdata *);
int smart_cksum(u_int8_t *, size_t);
char *sec_getpass(int, int);
struct command commands[] = {
{ "dump", device_dump },
{ "identify", device_identify },
{ "setidle", device_setidle },
{ "setstandby", device_setidle },
{ "idle", device_idle },
{ "standby", device_idle },
{ "sleep", device_idle },
{ "checkpower", device_checkpower },
{ "acousticdisable", device_feature },
{ "acousticset", device_acoustic },
{ "apmdisable", device_feature },
{ "apmset", device_apm },
{ "poddisable", device_feature },
{ "podenable", device_feature },
{ "puisdisable", device_feature },
{ "puisenable", device_feature },
{ "puisspinup", device_feature },
{ "readaheaddisable", device_feature },
{ "readaheadenable", device_feature },
{ "secsetpass", device_sec_setpass },
{ "secunlock", device_sec_unlock },
{ "secerase", device_sec_erase },
{ "secfreeze", device_sec_freeze },
{ "secdisablepass", device_sec_disablepass },
{ "smartenable", device_smart_enable },
{ "smartdisable", device_smart_disable },
{ "smartstatus", device_smart_status },
{ "smartautosave", device_smart_autosave },
{ "smartoffline", device_smart_offline },
{ "smartread", device_smart_read },
{ "smartreadlog", device_smart_readlog },
{ "readattr", device_attr },
{ "writecachedisable", device_feature },
{ "writecacheenable", device_feature },
{ NULL, NULL },
};
/*
* Tables containing bitmasks used for error reporting and
* device identification.
*/
struct bitinfo ata_caps[] = {
{ ATA_CAP_STBY, "ATA standby timer values" },
{ WDC_CAP_IORDY, "IORDY operation" },
{ WDC_CAP_IORDY_DSBL, "IORDY disabling" },
{ 0, NULL },
};
struct bitinfo ata_vers[] = {
{ WDC_VER_ATA1, "ATA-1" },
{ WDC_VER_ATA2, "ATA-2" },
{ WDC_VER_ATA3, "ATA-3" },
{ WDC_VER_ATA4, "ATA-4" },
{ WDC_VER_ATA5, "ATA-5" },
{ WDC_VER_ATA6, "ATA-6" },
{ WDC_VER_ATA7, "ATA-7" },
{ WDC_VER_ATA8, "ATA-8" },
{ WDC_VER_ATA9, "ATA-9" },
{ WDC_VER_ATA10, "ATA-10" },
{ WDC_VER_ATA11, "ATA-11" },
{ WDC_VER_ATA12, "ATA-12" },
{ WDC_VER_ATA13, "ATA-13" },
{ WDC_VER_ATA14, "ATA-14" },
{ 0, NULL },
};
struct bitinfo ata_cmd_set1[] = {
{ WDC_CMD1_NOP, "NOP command" },
{ WDC_CMD1_RB, "READ BUFFER command" },
{ WDC_CMD1_WB, "WRITE BUFFER command" },
{ WDC_CMD1_HPA, "Host Protected Area feature set" },
{ WDC_CMD1_DVRST, "DEVICE RESET command" },
{ WDC_CMD1_SRV, "SERVICE interrupt" },
{ WDC_CMD1_RLSE, "Release interrupt" },
{ WDC_CMD1_AHEAD, "Read look-ahead" },
{ WDC_CMD1_CACHE, "Write cache" },
{ WDC_CMD1_PKT, "PACKET command feature set" },
{ WDC_CMD1_PM, "Power Management feature set" },
{ WDC_CMD1_REMOV, "Removable Media feature set" },
{ WDC_CMD1_SEC, "Security Mode feature set" },
{ WDC_CMD1_SMART, "SMART feature set" },
{ 0, NULL },
};
struct bitinfo ata_cmd_set2[] = {
{ ATAPI_CMD2_FCE, "Flush Cache Ext command" },
{ ATAPI_CMD2_FC, "Flush Cache command" },
{ ATAPI_CMD2_DCO, "Device Configuration Overlay feature set" },
{ ATAPI_CMD2_48AD, "48bit address feature set" },
{ ATAPI_CMD2_AAM, "Automatic Acoustic Management feature set" },
{ ATAPI_CMD2_SM, "Set Max security extension commands" },
{ ATAPI_CMD2_SF, "Set Features subcommand required" },
{ ATAPI_CMD2_PUIS, "Power-up in standby feature set" },
{ WDC_CMD2_RMSN, "Removable Media Status Notification feature set" },
{ ATA_CMD2_APM, "Advanced Power Management feature set" },
{ ATA_CMD2_CFA, "CFA feature set" },
{ ATA_CMD2_RWQ, "READ/WRITE DMA QUEUED commands" },
{ WDC_CMD2_DM, "DOWNLOAD MICROCODE command" },
{ 0, NULL },
};
struct bitinfo ata_cmd_ext[] = {
{ ATAPI_CMDE_IIUF, "IDLE IMMEDIATE with UNLOAD FEATURE" },
{ ATAPI_CMDE_MSER, "Media serial number" },
{ ATAPI_CMDE_TEST, "SMART self-test" },
{ ATAPI_CMDE_SLOG, "SMART error logging" },
{ 0, NULL },
};
/*
* Tables containing bitmasks and values used for
* SMART commands.
*/
struct bitinfo smart_offcap[] = {
{ SMART_OFFCAP_EXEC, "execute immediate" },
{ SMART_OFFCAP_ABORT, "abort/restart" },
{ SMART_OFFCAP_READSCAN, "read scanning" },
{ SMART_OFFCAP_SELFTEST, "self-test routines" },
{ 0, NULL}
};
struct bitinfo smart_smartcap[] = {
{ SMART_SMARTCAP_SAVE, "saving SMART data" },
{ SMART_SMARTCAP_AUTOSAVE, "enable/disable attribute autosave" },
{ 0, NULL }
};
struct valinfo smart_autosave[] = {
{ SMART_AUTOSAVE_EN, "enable" },
{ SMART_AUTOSAVE_DS, "disable" },
{ 0, NULL }
};
struct valinfo smart_offline[] = {
{ SMART_OFFLINE_COLLECT, "collect" },
{ SMART_OFFLINE_SHORTOFF, "shortoffline" },
{ SMART_OFFLINE_EXTENOFF, "extenoffline" },
{ SMART_OFFLINE_ABORT, "abort" },
{ SMART_OFFLINE_SHORTCAP, "shortcaptive" },
{ SMART_OFFLINE_EXTENCAP, "extencaptive" },
{ 0, NULL }
};
struct valinfo smart_readlog[] = {
{ SMART_READLOG_DIR, "directory" },
{ SMART_READLOG_SUM, "summary" },
{ SMART_READLOG_COMP, "comp" },
{ SMART_READLOG_SELF, "selftest" },
{ 0, NULL }
};
struct valinfo smart_offstat[] = {
{ SMART_OFFSTAT_NOTSTART, "never started" },
{ SMART_OFFSTAT_COMPLETE, "completed ok" },
{ SMART_OFFSTAT_SUSPEND, "suspended by an interrupting command" },
{ SMART_OFFSTAT_INTR, "aborted by an interrupting command" },
{ SMART_OFFSTAT_ERROR, "aborted due to fatal error" },
{ 0, NULL }
};
struct valinfo smart_selfstat[] = {
{ SMART_SELFSTAT_COMPLETE, "completed ok or not started" },
{ SMART_SELFSTAT_ABORT, "aborted" },
{ SMART_SELFSTAT_INTR, "hardware or software reset" },
{ SMART_SELFSTAT_ERROR, "fatal error" },
{ SMART_SELFSTAT_UNKFAIL, "unknown test element failed" },
{ SMART_SELFSTAT_ELFAIL, "electrical test element failed" },
{ SMART_SELFSTAT_SRVFAIL, "servo test element failed" },
{ SMART_SELFSTAT_RDFAIL, "read test element failed" },
{ 0, NULL }
};
struct valinfo smart_logstat[] = {
{ SMART_LOG_STATE_UNK, "unknown" },
{ SMART_LOG_STATE_SLEEP, "sleep" },
{ SMART_LOG_STATE_ACTIDL, "active/idle" },
{ SMART_LOG_STATE_OFFSELF, "off-line or self-test" },
{ 0, NULL }
};
/*
* Tables containing values used for reading
* device attributes.
*/
struct valinfo ibm_attr_names[] = {
{ 1, "Raw Read Error Rate" },
{ 2, "Throughput Performance" },
{ 3, "Spin Up Time" },
{ 4, "Start/Stop Count" },
{ 5, "Reallocated Sector Count" },
{ 6, "Read Channel Margin" },
{ 7, "Seek Error Rate" },
{ 8, "Seek Time Performance" },
{ 9, "Power-On Hours Count" },
{ 10, "Spin Retry Count" },
{ 11, "Calibration Retry Count" },
{ 12, "Device Power Cycle Count" },
{ 13, "Soft Read Error Rate" },
{ 100, "Erase/Program Cycles" },
{ 103, "Translation Table Rebuild" },
{ 160, "Uncorrectable Error Count" },
{ 170, "Reserved Block Count" },
{ 171, "Program Fail Count" },
{ 172, "Erase Fail Count" },
{ 173, "Wear Worst Case Erase Count" },
{ 174, "Power-Off Retract Count" },
{ 175, "Program Fail Count" },
{ 176, "Erase Fail Count" },
{ 177, "Wear Leveling Count" },
{ 178, "Used Reserved Block Count" },
{ 179, "Used Reserved Block Count Total" },
{ 180, "Unused Reserved Block Count Total" },
{ 181, "Program Fail Count Total" },
{ 182, "Erase Fail Count" },
{ 183, "Runtime Bad Block" },
{ 184, "End-to-End error" },
{ 185, "Head Stability" },
{ 186, "Induced Op-Vibration Detection" },
{ 187, "Reported Uncorrectable Errors" },
{ 188, "Command Timeout" },
{ 189, "High Fly Writes" },
{ 190, "Airflow Temperature" },
{ 191, "G-Sense Error Rate" },
{ 192, "Power-Off Retract Count" },
{ 193, "Load Cycle Count" },
{ 194, "Temperature" },
{ 195, "Hardware ECC Recovered" },
{ 196, "Reallocation Event Count" },
{ 197, "Current Pending Sector Count" },
{ 198, "Off-Line Scan Uncorrectable Sector Count" },
{ 199, "Ultra DMA CRC Error Count" },
{ 200, "Write Error Rate" },
{ 201, "Soft Read Error Rate" },
{ 202, "Data Address Mark Errors" },
{ 203, "Run Out Cancel" },
{ 204, "Soft ECC Correction" },
{ 205, "Thermal Asperity Check" },
{ 206, "Flying Height" },
{ 207, "Spin High Current" },
{ 208, "Spin Buzz" },
{ 209, "Offline Seek Performance" },
{ 220, "Disk Shift" },
{ 221, "G-Sense Error Rate" },
{ 222, "Loaded Hours" },
{ 223, "Load/Unload Retry Count" },
{ 224, "Load Friction" },
{ 225, "Load/Unload Cycle Count" },
{ 226, "Load-In Time" },
{ 227, "Torque Amplification Count" },
{ 228, "Power-Off Retract Count" },
{ 230, "GMR Head Amplitude" },
{ 231, "Temperature" },
{ 232, "Available reserved space" },
{ 233, "Media wearout indicator" },
{ 235, "Power-Off Retract Count" },
{ 240, "Head Flying Hours" },
{ 241, "Total LBAs Written" },
{ 242, "Total LBAs Read" },
{ 249, "NAND Writes (1GB)" },
{ 250, "Read Error Retry Rate" },
{ 254, "Free Fall Sensor" },
{ 0, NULL },
};
#define MAKEWORD(b1, b2) \
(b2 << 8 | b1)
#define MAKEDWORD(b1, b2, b3, b4) \
(b4 << 24 | b3 << 16 | b2 << 8 | b1)
int
main(int argc, char *argv[])
{
struct command *cmdp;
if (argc < 2)
usage();
/*
* Open the device
*/
if ((fd = opendev(argv[1], O_RDWR, OPENDEV_PART, NULL)) == -1)
err(1, "%s", argv[1]);
/* Skip program name and device name. */
if (argc != 2) {
argv += 2;
argc -= 2;
} else {
argv[1] = "identify";
argv += 1;
argc -= 1;
}
/* Look up and call the command. */
for (cmdp = commands; cmdp->cmd_name != NULL; cmdp++)
if (strcmp(argv[0], cmdp->cmd_name) == 0)
break;
if (cmdp->cmd_name == NULL)
errx(1, "unknown command: %s", argv[0]);
(cmdp->cmd_func)(argc, argv);
return (0);
}
__dead void
usage(void)
{
fprintf(stderr, "usage: %s device [command [arg]]\n", __progname);
exit(1);
}
/*
* Wrapper that calls ATAIOCCOMMAND and checks for errors
*/
void
ata_command(struct atareq *req)
{
if (ioctl(fd, ATAIOCCOMMAND, req) == -1)
err(1, "ATAIOCCOMMAND failed");
switch (req->retsts) {
case ATACMD_OK:
return;
case ATACMD_TIMEOUT:
errx(1, "ATA command timed out");
case ATACMD_DF:
errx(1, "ATA device returned a Device Fault");
case ATACMD_ERROR:
if (req->error & WDCE_ABRT)
errx(1, "ATA device returned Aborted Command");
else
errx(1, "ATA device returned error register %0x",
req->error);
default:
errx(1, "ATAIOCCOMMAND returned unknown result code %d",
req->retsts);
}
}
/*
* Print out strings associated with particular bitmasks
*/
void
print_bitinfo(const char *f, u_int bits, struct bitinfo *binfo)
{
for (; binfo->bitmask != 0; binfo++)
if (bits & binfo->bitmask)
printf(f, binfo->string);
}
/*
* strtoval():
* returns value associated with given string,
* if no value found -1 is returned.
*/
int
strtoval(const char *str, struct valinfo *vinfo)
{
for (; vinfo->string != NULL; vinfo++)
if (strcmp(str, vinfo->string) == 0)
return (vinfo->value);
return (-1);
}
/*
* valtostr():
* returns string associated with given value,
* if no string found def value is returned.
*/
const char *
valtostr(int val, struct valinfo *vinfo, const char *def)
{
for (; vinfo->string != NULL; vinfo++)
if (val == vinfo->value)
return (vinfo->string);
return (def);
}
/*
* DEVICE COMMANDS
*/
/*
* device dump:
*
* extract issued ATA requests from the log buffer
*/
void
device_dump(int argc, char *argv[])
{
unsigned char buf[131072];
atagettrace_t agt;
unsigned int total;
unsigned int p = 0;
int type;
const char *types[] = { NULL, "status", "error", "ATAPI",
"ATAPI done", "ATA cmd", "ATA", "select slave",
"select master", "register read", "ATA LBA48" };
int num_types = sizeof(types) / sizeof(types[0]);
int info;
int entrysize;
int i;
int flags;
if (argc != 1)
goto usage;
memset(&agt, 0, sizeof(agt));
agt.buf_size = sizeof(buf);
agt.buf = buf;
if (ioctl(fd, ATAIOGETTRACE, &agt) == -1)
err(1, "ATAIOGETTRACE failed");
total = agt.bytes_copied;
/* Parse entries */
while (p < total) {
type = buf[p++];
if (p >= total)
return;
if (type <= 0 || type >= num_types)
return;
info = buf[p++];
if (p >= total)
return;
entrysize = (info & 0x1f);
printf ("ch %d", (info >> 5) & 0x7);
printf(": %s", types[type]);
switch (type) {
case WDCEVENT_STATUS:
if (entrysize != 1)
return;
printf(": 0x%x", buf[p]);
if (buf[p] & WDCS_BSY)
printf(" BSY");
if (buf[p] & WDCS_DRDY)
printf(" DRDY");
if (buf[p] & WDCS_DWF)
printf(" DWF");
if (buf[p] & WDCS_DSC)
printf(" DSC");
if (buf[p] & WDCS_DRQ)
printf(" DRQ");
if (buf[p] & WDCS_CORR)
printf(" CORR");
if (buf[p] & WDCS_IDX)
printf(" IDX");
if (buf[p] & WDCS_ERR)
printf(" ERR");
p++;
entrysize = 0;
break;
case WDCEVENT_ERROR:
if (entrysize != 1)
return;
printf(": 0x%x", buf[p]);
if (buf[p] & WDCE_BBK)
printf(" BBK/CRC");
if (buf[p] & WDCE_UNC)
printf(" UNC");
if (buf[p] & WDCE_MC)
printf(" MC");
if (buf[p] & WDCE_IDNF)
printf(" IDNF");
if (buf[p] & WDCE_MCR)
printf(" MCR");
if (buf[p] & WDCE_ABRT)
printf(" ABRT");
if (buf[p] & WDCE_TK0NF)
printf(" TK0NF");
if (buf[p] & WDCE_AMNF)
printf(" AMNF");
p++;
entrysize = 0;
break;
case WDCEVENT_ATAPI_CMD:
if (entrysize < 2 || p + 2 > total)
return;
flags = (buf[p] << 8) + buf[p + 1];
printf(": flags 0x%x", flags);
if (flags & 0x0100)
printf(" MEDIA");
if (flags & 0x0080)
printf(" SENSE");
if (flags & 0x0040)
printf(" DMA");
if (flags & 0x0020)
printf(" POLL");
if (flags & 0x0004)
printf(" TIMEOUT");
if (flags & 0x0002)
printf(" ATAPI");
p += 2;
entrysize -= 2;
break;
case WDCEVENT_ATAPI_DONE:
if (entrysize != 3 || p + 3 > total)
return;
flags = (buf[p] << 8) + buf[p + 1];
printf(": flags 0x%x", flags);
if (flags & 0x0100)
printf(" MEDIA");
if (flags & 0x0080)
printf(" SENSE");
if (flags & 0x0040)
printf(" DMA");
if (flags & 0x0020)
printf(" POLL");
if (flags & 0x0004)
printf(" TIMEOUT");
if (flags & 0x0002)
printf(" ATAPI");
printf(", error 0x%x", buf[p + 2]);
switch (buf[p + 2]) {
case 1:
printf(" (sense)");
break;
case 2:
printf(" (driver failure)");
break;
case 3:
printf(" (timeout)");
break;
case 4:
printf(" (busy)");
break;
case 5:
printf(" (ATAPI sense)");
break;
case 8:
printf(" (reset)");
break;
}
p += 3;
entrysize = 0;
break;
case WDCEVENT_ATA_LONG:
if (entrysize != 7 || p + 7 > total)
return;
printf(": ");
switch (buf[p + 6]) {
case WDCC_READDMA:
printf("READ DMA");
break;
case WDCC_WRITEDMA:
printf("WRITE DMA");
break;
default:
printf("CMD 0x%x", buf[p + 6]);
}
printf(" head %d, precomp %d, cyl_hi %d, "
"cyl_lo %d, sec %d, cnt %d",
buf[p], buf[p + 1], buf[p + 2], buf[p + 3],
buf[p + 4], buf[p + 5]);
p += 7;
entrysize = 0;
break;
case WDCEVENT_REG:
if (entrysize != 3 || p + 3 > total)
return;
switch (buf[p]) {
case 1:
printf(": error");
break;
case 2:
printf(": ireason");
break;
case 3:
printf(": lba_lo");
break;
case 4:
printf(": lba_mi");
break;
case 5:
printf(": lba_hi");
break;
case 6:
printf(": sdh");
break;
case 7:
printf(": status");
break;
case 8:
printf(": altstatus");
break;
default:
printf(": unknown register %d", buf[p]);
}
printf(": 0x%x", (buf[p + 1] << 8) + buf[p + 2]);
p += 3;
entrysize = 0;
break;
case WDCEVENT_ATA_EXT:
if (entrysize != 9 || p + 9 > total)
return;
printf(": ");
switch (buf[p + 8]) {
case WDCC_READDMA_EXT:
printf("READ DMA EXT");
break;
case WDCC_WRITEDMA_EXT:
printf("WRITE DMA EXT");
break;
default:
printf("CMD 0x%x", buf[p + 8]);
}
printf(" lba_hi1 %d, lba_hi2 %d, "
"lba_mi1 %d, lba_mi2 %d, lba_lo1 %d, lba_lo2 %d, "
"count1 %d, count2 %d",
buf[p], buf[p + 1], buf[p + 2], buf[p + 3],
buf[p + 4], buf[p + 5], buf[p + 6],
buf[p + 7]);
p += 9;
entrysize = 0;
break;
}
if (entrysize > 0)
printf(":");
for (i = 0; i < entrysize; i++) {
printf (" 0x%02x", buf[p]);
if (++p >= total)
break;
}
printf("\n");
}
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* device_identify:
*
* Display the identity of the device
*/
void
device_identify(int argc, char *argv[])
{
struct ataparams *inqbuf;
struct atareq req;
char inbuf[DEV_BSIZE];
u_int64_t capacity;
u_int8_t *s;
if (argc != 1)
goto usage;
memset(&inbuf, 0, sizeof(inbuf));
memset(&req, 0, sizeof(req));
inqbuf = (struct ataparams *) inbuf;
req.flags = ATACMD_READ;
req.command = WDCC_IDENTIFY;
req.databuf = (caddr_t) inbuf;
req.datalen = sizeof(inbuf);
req.timeout = 1000;
ata_command(&req);
if (BYTE_ORDER == BIG_ENDIAN) {
swap16_multi((u_int16_t *)inbuf, 10);
swap16_multi(((u_int16_t *)inbuf) + 20, 3);
swap16_multi(((u_int16_t *)inbuf) + 47, sizeof(inbuf) / 2 - 47);
}
if (!((inqbuf->atap_config & WDC_CFG_ATAPI_MASK) == WDC_CFG_ATAPI &&
((inqbuf->atap_model[0] == 'N' &&
inqbuf->atap_model[1] == 'E') ||
(inqbuf->atap_model[0] == 'F' &&
inqbuf->atap_model[1] == 'X')))) {
swap16_multi((u_int16_t *)(inqbuf->atap_model),
sizeof(inqbuf->atap_model) / 2);
swap16_multi((u_int16_t *)(inqbuf->atap_serial),
sizeof(inqbuf->atap_serial) / 2);
swap16_multi((u_int16_t *)(inqbuf->atap_revision),
sizeof(inqbuf->atap_revision) / 2);
}
/*
* Strip blanks off of the info strings.
*/
for (s = &inqbuf->atap_model[sizeof(inqbuf->atap_model) - 1];
s >= inqbuf->atap_model && *s == ' '; s--)
*s = '\0';
for (s = &inqbuf->atap_revision[sizeof(inqbuf->atap_revision) - 1];
s >= inqbuf->atap_revision && *s == ' '; s--)
*s = '\0';
for (s = &inqbuf->atap_serial[sizeof(inqbuf->atap_serial) - 1];
s >= inqbuf->atap_serial && *s == ' '; s--)
*s = '\0';
printf("Model: %.*s, Rev: %.*s, Serial #: %.*s\n",
(int) sizeof(inqbuf->atap_model), inqbuf->atap_model,
(int) sizeof(inqbuf->atap_revision), inqbuf->atap_revision,
(int) sizeof(inqbuf->atap_serial), inqbuf->atap_serial);
printf("Device type: %s, %s\n", inqbuf->atap_config & WDC_CFG_ATAPI ?
"ATAPI" : "ATA", inqbuf->atap_config & ATA_CFG_FIXED ? "fixed" :
"removable");
if (inqbuf->atap_cmd2_en & ATAPI_CMD2_48AD)
capacity = ((u_int64_t)inqbuf->atap_max_lba[3] << 48) |
((u_int64_t)inqbuf->atap_max_lba[2] << 32) |
((u_int64_t)inqbuf->atap_max_lba[1] << 16) |
(u_int64_t)inqbuf->atap_max_lba[0];
else
capacity = (inqbuf->atap_capacity[1] << 16) |
inqbuf->atap_capacity[0];
printf("Cylinders: %d, heads: %d, sec/track: %d, total "
"sectors: %llu\n", inqbuf->atap_cylinders,
inqbuf->atap_heads, inqbuf->atap_sectors, capacity);
if ((inqbuf->atap_cmd_set2 & ATA_CMD2_RWQ) &&
(inqbuf->atap_queuedepth & WDC_QUEUE_DEPTH_MASK))
printf("Device supports command queue depth of %d\n",
(inqbuf->atap_queuedepth & WDC_QUEUE_DEPTH_MASK) + 1);
printf("Device capabilities:\n");
print_bitinfo("\t%s\n", inqbuf->atap_capabilities1, ata_caps);
if (inqbuf->atap_ata_major != 0 && inqbuf->atap_ata_major != 0xffff) {
printf("Device supports the following standards:\n");
print_bitinfo("%s ", inqbuf->atap_ata_major, ata_vers);
printf("\n");
}
if ((inqbuf->atap_cmd_set1 & WDC_CMD1_SEC) &&
inqbuf->atap_mpasswd_rev != 0 &&
inqbuf->atap_mpasswd_rev != 0xffff)
printf("Master password revision code 0x%04x\n",
inqbuf->atap_mpasswd_rev);
if (inqbuf->atap_cmd_set1 != 0 && inqbuf->atap_cmd_set1 != 0xffff &&
inqbuf->atap_cmd_set2 != 0 && inqbuf->atap_cmd_set2 != 0xffff) {
printf("Device supports the following command sets:\n");
print_bitinfo("\t%s\n", inqbuf->atap_cmd_set1, ata_cmd_set1);
print_bitinfo("\t%s\n", inqbuf->atap_cmd_set2, ata_cmd_set2);
print_bitinfo("\t%s\n", inqbuf->atap_cmd_ext, ata_cmd_ext);
}
if (inqbuf->atap_cmd_def != 0 && inqbuf->atap_cmd_def != 0xffff) {
printf("Device has enabled the following command "
"sets/features:\n");
print_bitinfo("\t%s\n", inqbuf->atap_cmd1_en, ata_cmd_set1);
print_bitinfo("\t%s\n", inqbuf->atap_cmd2_en, ata_cmd_set2);
}
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* device idle:
*
* issue the IDLE IMMEDIATE command to the drive
*/
void
device_idle(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
if (strcmp(argv[0], "idle") == 0)
req.command = WDCC_IDLE_IMMED;
else if (strcmp(argv[0], "standby") == 0)
req.command = WDCC_STANDBY_IMMED;
else
req.command = WDCC_SLEEP;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SECURITY SET PASSWORD command
*/
void
device_sec_setpass(int argc, char *argv[])
{
struct atareq req;
struct sec_password pwd;
char *pass, inbuf[DEV_BSIZE];
struct ataparams *inqbuf = (struct ataparams *)inbuf;
if (argc < 2)
goto usage;
memset(&pwd, 0, sizeof(pwd));
if (strcmp(argv[1], "user") == 0 && argc == 3)
pwd.ctrl |= SEC_PASSWORD_USER;
else if (strcmp(argv[1], "master") == 0 && argc == 2)
pwd.ctrl |= SEC_PASSWORD_MASTER;
else
goto usage;
if (argc == 3) {
if (strcmp(argv[2], "high") == 0)
pwd.ctrl |= SEC_LEVEL_HIGH;
else if (strcmp(argv[2], "maximum") == 0)
pwd.ctrl |= SEC_LEVEL_MAX;
else
goto usage;
}
/*
* Issue IDENTIFY command to obtain master password
* revision code and decrement its value.
* The valid revision codes are 0x0001 through 0xfffe.
* If the device returns 0x0000 or 0xffff as a revision
* code then the master password revision code is not
* supported so don't touch it.
*/
memset(&inbuf, 0, sizeof(inbuf));
memset(&req, 0, sizeof(req));
req.command = WDCC_IDENTIFY;
req.timeout = 1000;
req.flags = ATACMD_READ;
req.databuf = (caddr_t)inbuf;
req.datalen = sizeof(inbuf);
ata_command(&req);
pwd.revision = inqbuf->atap_mpasswd_rev;
if (pwd.revision != 0 && pwd.revision != 0xffff && --pwd.revision == 0)
pwd.revision = 0xfffe;
pass = sec_getpass(pwd.ctrl & SEC_PASSWORD_MASTER, 1);
memcpy(pwd.password, pass, strlen(pass));
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_SET_PASSWORD;
req.timeout = 1000;
req.flags = ATACMD_WRITE;
req.databuf = (caddr_t)&pwd;
req.datalen = sizeof(pwd);
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s user high | maximum\n",
__progname, argv[0]);
fprintf(stderr, " %s device %s master\n", __progname, argv[0]);
exit(1);
}
/*
* SECURITY UNLOCK command
*/
void
device_sec_unlock(int argc, char *argv[])
{
struct atareq req;
struct sec_password pwd;
char *pass;
if (argc != 2)
goto usage;
memset(&pwd, 0, sizeof(pwd));
if (strcmp(argv[1], "user") == 0)
pwd.ctrl |= SEC_PASSWORD_USER;
else if (strcmp(argv[1], "master") == 0)
pwd.ctrl |= SEC_PASSWORD_MASTER;
else
goto usage;
pass = sec_getpass(pwd.ctrl & SEC_PASSWORD_MASTER, 0);
memcpy(pwd.password, pass, strlen(pass));
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_UNLOCK;
req.timeout = 1000;
req.flags = ATACMD_WRITE;
req.databuf = (caddr_t)&pwd;
req.datalen = sizeof(pwd);
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s user | master\n", __progname,
argv[0]);
exit(1);
}
/*
* SECURITY ERASE UNIT command
*/
void
device_sec_erase(int argc, char *argv[])
{
struct atareq req;
struct sec_password pwd;
char *pass;
if (argc < 2)
goto usage;
memset(&pwd, 0, sizeof(pwd));
if (strcmp(argv[1], "user") == 0)
pwd.ctrl |= SEC_PASSWORD_USER;
else if (strcmp(argv[1], "master") == 0)
pwd.ctrl |= SEC_PASSWORD_MASTER;
else
goto usage;
if (argc == 2)
pwd.ctrl |= SEC_ERASE_NORMAL;
else if (argc == 3 && strcmp(argv[2], "enhanced") == 0)
pwd.ctrl |= SEC_ERASE_ENHANCED;
else
goto usage;
pass = sec_getpass(pwd.ctrl & SEC_PASSWORD_MASTER, 0);
memcpy(pwd.password, pass, strlen(pass));
/* Issue SECURITY ERASE PREPARE command before */
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_ERASE_PREPARE;
req.timeout = 1000;
ata_command(&req);
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_ERASE_UNIT;
req.timeout = 1000;
req.flags = ATACMD_WRITE;
req.databuf = (caddr_t)&pwd;
req.datalen = sizeof(pwd);
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s user | master [enhanced]\n",
__progname, argv[0]);
exit(1);
}
/*
* SECURITY FREEZE LOCK command
*/
void
device_sec_freeze(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_FREEZE_LOCK;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SECURITY DISABLE PASSWORD command
*/
void
device_sec_disablepass(int argc, char *argv[])
{
struct atareq req;
struct sec_password pwd;
char *pass;
if (argc != 2)
goto usage;
memset(&pwd, 0, sizeof(pwd));
if (strcmp(argv[1], "user") == 0)
pwd.ctrl |= SEC_PASSWORD_USER;
else if (strcmp(argv[1], "master") == 0)
pwd.ctrl |= SEC_PASSWORD_MASTER;
else
goto usage;
pass = sec_getpass(pwd.ctrl & SEC_PASSWORD_MASTER, 0);
memcpy(pwd.password, pass, strlen(pass));
memset(&req, 0, sizeof(req));
req.command = ATA_SEC_DISABLE_PASSWORD;
req.timeout = 1000;
req.flags = ATACMD_WRITE;
req.databuf = (caddr_t)&pwd;
req.datalen = sizeof(pwd);
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s user | master\n", __progname,
argv[0]);
exit(1);
}
char *
sec_getpass(int ident, int confirm)
{
char *pass, buf[33];
if ((pass = getpass(ident ? "Master password:" :
"User password:")) == NULL)
err(1, "getpass()");
if (strlen(pass) > 32)
errx(1, "password too long");
if (confirm) {
strlcpy(buf, pass, sizeof(buf));
if ((pass = getpass(ident ? "Retype master password:" :
"Retype user password:")) == NULL)
err(1, "getpass()");
if (strcmp(pass, buf) != 0)
errx(1, "password mismatch");
}
return (pass);
}
/*
* SMART ENABLE OPERATIONS command
*/
void
device_smart_enable(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_EN;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SMART DISABLE OPERATIONS command
*/
void
device_smart_disable(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_DS;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SMART STATUS command
*/
void
device_smart_status(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_STATUS;
ata_command(&req);
if (req.cylinder == 0xc24f)
printf("No SMART threshold exceeded\n");
else if (req.cylinder == 0x2cf4) {
errx(2, "SMART threshold exceeded!");
} else {
errx(1, "Unknown response %02x!", req.cylinder);
}
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SMART ENABLE/DISABLE ATTRIBUTE AUTOSAVE command
*/
void
device_smart_autosave(int argc, char *argv[])
{
struct atareq req;
int val;
if (argc != 2)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_AUTOSAVE;
if ((val = strtoval(argv[1], smart_autosave)) == -1)
goto usage;
req.sec_num = val;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s enable | disable\n", __progname,
argv[0]);
exit(1);
}
/*
* SMART EXECUTE OFF-LINE IMMEDIATE command
*/
void
device_smart_offline(int argc, char *argv[])
{
struct atareq req;
int val;
if (argc != 2)
goto usage;
memset(&req, 0, sizeof(req));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_OFFLINE;
if ((val = strtoval(argv[1], smart_offline)) == -1)
goto usage;
req.sec_num = val;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s subcommand\n", __progname,
argv[0]);
exit(1);
}
/*
* SMART READ DATA command
*/
void
device_smart_read(int argc, char *argv[])
{
struct atareq req;
struct smart_read data;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
memset(&data, 0, sizeof(data));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_READ;
req.flags = ATACMD_READ;
req.databuf = (caddr_t)&data;
req.datalen = sizeof(data);
ata_command(&req);
if (smart_cksum((u_int8_t *)&data, sizeof(data)) != 0)
errx(1, "Checksum mismatch");
printf("Off-line data collection:\n");
printf(" status: %s\n",
valtostr(data.offstat & 0x7f, smart_offstat, "?"));
printf(" activity completion time: %d seconds\n",
letoh16(data.time));
printf(" capabilities:\n");
print_bitinfo("\t%s\n", data.offcap, smart_offcap);
printf("Self-test execution:\n");
printf(" status: %s\n", valtostr(SMART_SELFSTAT_STAT(data.selfstat),
smart_selfstat, "?"));
if (SMART_SELFSTAT_STAT(data.selfstat) == SMART_SELFSTAT_PROGRESS)
printf("remains %d%% of total time\n",
SMART_SELFSTAT_PCNT(data.selfstat));
printf(" recommended polling time:\n");
printf("\tshort routine: %d minutes\n", data.shtime);
printf("\textended routine: %d minutes\n", data.extime);
printf("SMART capabilities:\n");
print_bitinfo(" %s\n", letoh16(data.smartcap), smart_smartcap);
printf("Error logging: ");
if (data.errcap & SMART_ERRCAP_ERRLOG)
printf("supported\n");
else
printf("not supported\n");
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* SMART READ LOG command
*/
void
device_smart_readlog(int argc, char *argv[])
{
struct atareq req;
int val;
u_int8_t inbuf[DEV_BSIZE];
if (argc != 2)
goto usage;
memset(&req, 0, sizeof(req));
memset(&inbuf, 0, sizeof(inbuf));
req.command = ATAPI_SMART;
req.cylinder = 0xc24f;
req.timeout = 1000;
req.features = ATA_SMART_READLOG;
req.flags = ATACMD_READ;
req.sec_count = 1;
req.databuf = (caddr_t)inbuf;
req.datalen = sizeof(inbuf);
if ((val = strtoval(argv[1], smart_readlog)) == -1)
goto usage;
req.sec_num = val;
ata_command(&req);
if (strcmp(argv[1], "directory") == 0) {
struct smart_log_dir *data = (struct smart_log_dir *)inbuf;
int i;
if (data->version != SMART_LOG_MSECT) {
printf("Device doesn't support multi-sector logs\n");
return;
}
for (i = 0; i < 255; i++)
printf("Log address %d: %d sectors\n", i + 1,
data->entry[i].sec_num);
} else if (strcmp(argv[1], "summary") == 0) {
struct smart_log_sum *data = (struct smart_log_sum *)inbuf;
int i, n, nerr;
if (smart_cksum(inbuf, sizeof(inbuf)) != 0)
errx(1, "Checksum mismatch");
if (data->index == 0) {
printf("No log entries\n");
return;
}
nerr = letoh16(data->err_cnt);
printf("Error count: %d\n\n", nerr);
/*
* Five error log data structures form a circular
* buffer. data->index points to the most recent
* record and err_cnt contains total error number.
* We pass from the most recent record to the
* latest one.
*/
i = data->index - 1;
n = 0;
do {
printf("Error %d:\n", n + 1);
smart_print_errdata(&data->errdata[i--]);
if (i == -1)
i = 4;
} while (++n < (nerr > 5 ? 5 : nerr));
} else if (strcmp(argv[1], "comp") == 0) {
struct smart_log_comp *data = (struct smart_log_comp *)inbuf;
u_int8_t *newbuf;
int i, n, nerr, nsect;
if (smart_cksum(inbuf, sizeof(inbuf)) != 0)
errx(1, "Checksum mismatch");
if (data->index == 0) {
printf("No log entries\n");
return;
}
i = data->index - 1;
nerr = letoh16(data->err_cnt);
printf("Error count: %d\n", nerr);
/*
* From the first sector we obtain total error number
* and calculate necessary number of sectors to read.
* All read error data structures form a circular
* buffer and we pass from the most recent record to
* the latest one.
*/
nsect = nerr / 5 + (nerr % 5 != 0 ? 1 : 0);
if ((newbuf = calloc(nsect, DEV_BSIZE)) == NULL)
err(1, "calloc()");
memset(&req, 0, sizeof(req));
req.flags = ATACMD_READ;
req.command = ATAPI_SMART;
req.features = ATA_SMART_READLOG;
req.sec_count = nsect;
req.sec_num = SMART_READLOG_COMP;
req.cylinder = 0xc24f;
req.databuf = (caddr_t)newbuf;
req.datalen = nsect * DEV_BSIZE;
req.timeout = 1000;
ata_command(&req);
n = 0;
data = (struct smart_log_comp *)
(newbuf + (nsect - 1) * DEV_BSIZE);
do {
printf("Error %d:\n", n + 1);
smart_print_errdata(&data->errdata[i-- % 5]);
if (i == -1)
i = 254;
if (i % 5 == 4)
data = (struct smart_log_comp *)
(newbuf + (i / 5) * DEV_BSIZE);
} while (++n < nerr);
} else if (strcmp(argv[1], "selftest") == 0) {
struct smart_log_self *data = (struct smart_log_self *)inbuf;
int i, n;
if (smart_cksum(inbuf, sizeof(inbuf)) != 0)
errx(1, "Checksum mismatch");
if (data->index == 0) {
printf("No log entries\n");
return;
}
/* circular buffer of 21 entries */
i = data->index - 1;
n = 0;
do {
/* don't print empty entries */
if ((data->desc[i].time1 | data->desc[i].time2) == 0)
break;
printf("Test %d\n", n + 1);
printf(" LBA Low: 0x%x\n", data->desc[i].reg_lbalo);
printf(" status: %s\n",
valtostr(SMART_SELFSTAT_STAT(
data->desc[i].selfstat),
smart_selfstat, "?"));
printf(" timestamp: %d\n",
MAKEWORD(data->desc[i].time1,
data->desc[i].time2));
printf(" failure checkpoint byte: 0x%x\n",
data->desc[i].chkpnt);
printf(" failing LBA: 0x%x\n",
MAKEDWORD(data->desc[i].lbafail1,
data->desc[i].lbafail2,
data->desc[i].lbafail3,
data->desc[i].lbafail4));
if (--i == -1)
i = 20;
} while (++n < 21);
}
return;
usage:
fprintf(stderr, "usage: %s device %s log\n", __progname, argv[0]);
exit(1);
}
#define SMART_PRINTREG(str, reg) \
printf(str "0x%02x\t0x%02x\t0x%02x\t0x%02x\t0x%02x\n", \
data->cmd[0].reg, \
data->cmd[1].reg, \
data->cmd[2].reg, \
data->cmd[3].reg, \
data->cmd[4].reg)
void
smart_print_errdata(struct smart_log_errdata *data)
{
printf(" error register: 0x%x\n", data->err.reg_err);
printf(" sector count register: 0x%x\n", data->err.reg_seccnt);
printf(" LBA Low register: 0x%x\n", data->err.reg_lbalo);
printf(" LBA Mid register: 0x%x\n", data->err.reg_lbamid);
printf(" LBA High register: 0x%x\n", data->err.reg_lbahi);
printf(" device register: 0x%x\n", data->err.reg_dev);
printf(" status register: 0x%x\n", data->err.reg_stat);
printf(" state: %s\n", valtostr(data->err.state, smart_logstat, "?"));
printf(" timestamp: %d\n", MAKEWORD(data->err.time1,
data->err.time2));
printf(" history:\n");
SMART_PRINTREG("\tcontrol register:\t", reg_ctl);
SMART_PRINTREG("\tfeatures register:\t", reg_feat);
SMART_PRINTREG("\tsector count register:\t", reg_seccnt);
SMART_PRINTREG("\tLBA Low register:\t", reg_lbalo);
SMART_PRINTREG("\tLBA Mid register:\t", reg_lbamid);
SMART_PRINTREG("\tLBA High register:\t", reg_lbahi);
SMART_PRINTREG("\tdevice register:\t", reg_dev);
SMART_PRINTREG("\tcommand register:\t", reg_cmd);
printf("\ttimestamp:\t\t"
"%d\t%d\t%d\t%d\t%d\n",
MAKEDWORD(data->cmd[0].time1, data->cmd[0].time2,
data->cmd[0].time3, data->cmd[0].time4),
MAKEDWORD(data->cmd[1].time1, data->cmd[1].time2,
data->cmd[1].time3, data->cmd[1].time4),
MAKEDWORD(data->cmd[2].time1, data->cmd[2].time2,
data->cmd[2].time3, data->cmd[2].time4),
MAKEDWORD(data->cmd[3].time1, data->cmd[3].time2,
data->cmd[3].time3, data->cmd[3].time4),
MAKEDWORD(data->cmd[4].time1, data->cmd[4].time2,
data->cmd[4].time3, data->cmd[4].time4));
}
int
smart_cksum(u_int8_t *data, size_t len)
{
u_int8_t sum = 0;
size_t i;
for (i = 0; i < len; i++)
sum += data[i];
return (sum);
}
/*
* Read device attributes
*/
void
device_attr(int argc, char *argv[])
{
struct atareq req;
struct smart_read attr_val;
struct smart_threshold attr_thr;
struct attribute *attr;
struct threshold *thr;
const char *attr_name;
static const char hex[]="0123456789abcdef";
char raw[13], *format;
int i, k, threshold_exceeded = 0;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
memset(&attr_val, 0, sizeof(attr_val)); /* XXX */
memset(&attr_thr, 0, sizeof(attr_thr)); /* XXX */
req.command = ATAPI_SMART;
req.cylinder = 0xc24f; /* LBA High = C2h, LBA Mid = 4Fh */
req.timeout = 1000;
req.features = ATA_SMART_READ;
req.flags = ATACMD_READ;
req.databuf = (caddr_t)&attr_val;
req.datalen = sizeof(attr_val);
ata_command(&req);
req.features = ATA_SMART_THRESHOLD;
req.flags = ATACMD_READ;
req.databuf = (caddr_t)&attr_thr;
req.datalen = sizeof(attr_thr);
ata_command(&req);
if (smart_cksum((u_int8_t *)&attr_val, sizeof(attr_val)) != 0)
errx(1, "Checksum mismatch (attr_val)");
if (smart_cksum((u_int8_t *)&attr_thr, sizeof(attr_thr)) != 0)
errx(1, "Checksum mismatch (attr_thr)");
attr = attr_val.attribute;
thr = attr_thr.threshold;
printf("Attributes table revision: %d\n", attr_val.revision);
printf("ID\tAttribute name\t\t\tThreshold\tValue\tRaw\n");
for (i = 0; i < 30; i++) {
if (thr[i].id != 0 && thr[i].id == attr[i].id) {
attr_name = valtostr(thr[i].id, ibm_attr_names,
"Unknown");
for (k = 0; k < 6; k++) {
u_int8_t b;
b = attr[i].raw[6 - k];
raw[k + k] = hex[b >> 4];
raw[k + k + 1] = hex[b & 0x0f];
}
raw[k + k] = '\0';
if (thr[i].value >= attr[i].value) {
++threshold_exceeded;
format = "%3d *%-32.32s %3d\t\t%3d\t0x%s\n";
} else {
format = "%3d\t%-32.32s %3d\t\t%3d\t0x%s\n";
}
printf(format, thr[i].id, attr_name,
thr[i].value, attr[i].value, raw);
}
}
if (threshold_exceeded)
fprintf(stderr, "One or more threshold values exceeded!\n");
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* Set the automatic acoustic management on the disk.
*/
void
device_acoustic(int argc, char *argv[])
{
u_char acoustic;
struct atareq req;
const char *errstr;
if (argc != 2)
goto usage;
acoustic = strtonum(argv[1], 0, 126, &errstr);
if (errstr)
errx(1, "Acoustic management value \"%s\" is %s "
"(valid values: 0 - 126)", argv[1], errstr);
memset(&req, 0, sizeof(req));
req.sec_count = acoustic + 0x80;
req.command = SET_FEATURES ;
req.features = WDSF_AAM_EN ;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s acoustic-management-level\n",
__progname, argv[0]);
exit(1);
}
/*
* Set the advanced power managmement on the disk. Power management
* levels are translated from user-range 0-253 to ATAPI levels 1-0xFD
* to keep a uniform interface to the user.
*/
void
device_apm(int argc, char *argv[])
{
u_char power;
struct atareq req;
const char *errstr;
if (argc != 2)
goto usage;
power = strtonum(argv[1], 0, 253, &errstr);
if (errstr)
errx(1, "Advanced power management value \"%s\" is %s "
"(valid values: 0 - 253)", argv[1], errstr);
memset(&req, 0, sizeof(req));
req.sec_count = power + 0x01;
req.command = SET_FEATURES ;
req.features = WDSF_APM_EN ;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s power-management-level\n",
__progname, argv[0]);
exit(1);
}
/*
* En/disable features (the automatic acoustic managmement, Advanced Power
* Management) on the disk.
*/
void
device_feature(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = SET_FEATURES ;
if (strcmp(argv[0], "acousticdisable") == 0)
req.features = WDSF_AAM_DS;
else if (strcmp(argv[0], "readaheadenable") == 0)
req.features = WDSF_READAHEAD_EN;
else if (strcmp(argv[0], "readaheaddisable") == 0)
req.features = WDSF_READAHEAD_DS;
else if (strcmp(argv[0], "writecacheenable") == 0)
req.features = WDSF_EN_WR_CACHE;
else if (strcmp(argv[0], "writecachedisable") == 0)
req.features = WDSF_WRITE_CACHE_DS;
else if (strcmp(argv[0], "apmdisable") == 0)
req.features = WDSF_APM_DS;
else if (strcmp(argv[0], "podenable") == 0)
req.features = WDSF_POD_EN;
else if (strcmp(argv[0], "poddisable") == 0)
req.features = WDSF_POD_DS;
else if (strcmp(argv[0], "puisenable") == 0)
req.features = WDSF_PUIS_EN;
else if (strcmp(argv[0], "puisdisable") == 0)
req.features = WDSF_PUIS_DS;
else if (strcmp(argv[0], "puisspinup") == 0)
req.features = WDSF_PUIS_SPINUP;
else
goto usage;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
/*
* Set the idle timer on the disk. Set it for either idle mode or
* standby mode, depending on how we were invoked.
*/
void
device_setidle(int argc, char *argv[])
{
unsigned long idle;
struct atareq req;
char *end;
if (argc != 2)
goto usage;
idle = strtoul(argv[1], &end, 0);
if (*end != '\0' || idle > 19800)
errx(1, "Invalid idle time: \"%s\" "
"(valid values: 1 - 19800)", argv[1]);
if (idle != 0 && idle < 5)
errx(1, "Idle timer must be at least 5 seconds");
memset(&req, 0, sizeof(req));
if (idle <= 240 * 5)
req.sec_count = idle / 5;
else
req.sec_count = idle / (30 * 60) + 240;
if (strcmp(argv[0], "setstandby") == 0)
req.command = WDCC_STANDBY;
else if (strcmp(argv[0], "setidle") == 0)
req.command = WDCC_IDLE;
else
goto usage;
req.timeout = 1000;
ata_command(&req);
return;
usage:
fprintf(stderr, "usage: %s device %s %s\n", __progname, argv[0],
(strcmp(argv[0], "setidle") == 0) ? "idle-timer" : "standby-timer");
exit(1);
}
/*
* Query the device for the current power mode
*/
void
device_checkpower(int argc, char *argv[])
{
struct atareq req;
if (argc != 1)
goto usage;
memset(&req, 0, sizeof(req));
req.command = WDCC_CHECK_PWR;
req.timeout = 1000;
req.flags = ATACMD_READREG;
ata_command(&req);
printf("Current power status: ");
switch (req.sec_count) {
case 0x00:
printf("Standby mode\n");
break;
case 0x80:
printf("Idle mode\n");
break;
case 0xff:
printf("Active mode\n");
break;
default:
printf("Unknown power code (%02x)\n", req.sec_count);
}
return;
usage:
fprintf(stderr, "usage: %s device %s\n", __progname, argv[0]);
exit(1);
}
![[BACK]](/icons/back.gif){kind=icon}
Return to atactl.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / sbin / atactl