1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-17 10:26:15 +00:00
freebsd/sbin/atacontrol/atacontrol.c
Craig Rodrigues 8d1a3b6998 Add a "kern.features.ata_cam" sysctl in the kernel when the ATA_CAM kernel
option is defined.  This sysctl can be queried by feature_present(3).

Query for this feature in /sbin/atacontrol and /usr/sbin/burncd.
If these utilities detect that ATA_CAM is enabled, then these utilities
will error out.  These utilities are compatible with the old ATA
driver, but are incomptible with the new ATA_CAM driver.  By erroring out,
we give end-users an idea as to what remedies to use, and reduce the need for them
to file PR's.  For atacontrol, camcontrol must be used instead,
and for burncd, alternative utilties from the ports collection must be used
such as sysutils/cdrtools.

In future, maybe someone can re-write burncd to work with ATA_CAM,
but at least for now, we give a somewhat useful error message to end users.

PR:		160979
Reviewed by:	jh, Arnaud Lacombe <lacombar at gmail dot com>
Reported by:	Joe Barbish <fbsd8 at a1poweruser dot com>
MFC after:	3 days
2011-10-09 21:42:02 +00:00

645 lines
18 KiB
C

/*-
* Copyright (c) 2000 - 2006 Søren Schmidt <sos@FreeBSD.org>
* All rights reserved.
*
* 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,
* without modification, immediately at the beginning of the file.
* 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 AUTHOR ``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 AUTHOR 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.
*
* $FreeBSD$
*/
#include <sys/types.h>
#include <sys/ata.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>
#include <unistd.h>
static const char *
mode2str(int mode)
{
switch (mode & 0xff) {
case ATA_PIO: return "BIOSPIO";
case ATA_PIO0: return "PIO0";
case ATA_PIO1: return "PIO1";
case ATA_PIO2: return "PIO2";
case ATA_PIO3: return "PIO3";
case ATA_PIO4: return "PIO4";
case ATA_WDMA0: return "WDMA0";
case ATA_WDMA1: return "WDMA1";
case ATA_WDMA2: return "WDMA2";
case ATA_UDMA0: return "UDMA0";
case ATA_UDMA1: return "UDMA1";
case ATA_UDMA2: return "UDMA33";
case ATA_UDMA3: return "UDMA44";
case ATA_UDMA4: return "UDMA66";
case ATA_UDMA5: return "UDMA100";
case ATA_UDMA6: return "UDMA133";
case ATA_DMA: return "BIOSDMA";
default: return "???";
}
}
static const char *
satarev2str(int mode)
{
switch ((mode & 0xff00) >> 8) {
case 0: return "";
case 1: return "SATA 1.5Gb/s";
case 2: return "SATA 3Gb/s";
case 3: return "SATA 6Gb/s";
case 0xff: return "SATA";
default: return "???";
}
}
static int
str2mode(char *str)
{
if (!strcasecmp(str, "BIOSPIO")) return ATA_PIO;
if (!strcasecmp(str, "PIO0")) return ATA_PIO0;
if (!strcasecmp(str, "PIO1")) return ATA_PIO1;
if (!strcasecmp(str, "PIO2")) return ATA_PIO2;
if (!strcasecmp(str, "PIO3")) return ATA_PIO3;
if (!strcasecmp(str, "PIO4")) return ATA_PIO4;
if (!strcasecmp(str, "WDMA0")) return ATA_WDMA0;
if (!strcasecmp(str, "WDMA1")) return ATA_WDMA1;
if (!strcasecmp(str, "WDMA2")) return ATA_WDMA2;
if (!strcasecmp(str, "UDMA0")) return ATA_UDMA0;
if (!strcasecmp(str, "UDMA16")) return ATA_UDMA0;
if (!strcasecmp(str, "UDMA1")) return ATA_UDMA1;
if (!strcasecmp(str, "UDMA25")) return ATA_UDMA1;
if (!strcasecmp(str, "UDMA2")) return ATA_UDMA2;
if (!strcasecmp(str, "UDMA33")) return ATA_UDMA2;
if (!strcasecmp(str, "UDMA3")) return ATA_UDMA3;
if (!strcasecmp(str, "UDMA44")) return ATA_UDMA3;
if (!strcasecmp(str, "UDMA4")) return ATA_UDMA4;
if (!strcasecmp(str, "UDMA66")) return ATA_UDMA4;
if (!strcasecmp(str, "UDMA5")) return ATA_UDMA5;
if (!strcasecmp(str, "UDMA100")) return ATA_UDMA5;
if (!strcasecmp(str, "UDMA6")) return ATA_UDMA6;
if (!strcasecmp(str, "UDMA133")) return ATA_UDMA6;
if (!strcasecmp(str, "BIOSDMA")) return ATA_DMA;
return -1;
}
static void
usage(void)
{
fprintf(stderr,
"usage: atacontrol <command> args:\n"
" atacontrol list\n"
" atacontrol info channel\n"
" atacontrol attach channel\n"
" atacontrol detach channel\n"
" atacontrol reinit channel\n"
" atacontrol create type [interleave] disk0 ... diskN\n"
" atacontrol delete array\n"
" atacontrol addspare array disk\n"
" atacontrol rebuild array\n"
" atacontrol status array\n"
" atacontrol mode device [mode]\n"
" atacontrol cap device\n"
" atacontrol spindown device [seconds]\n"
);
exit(EX_USAGE);
}
static int
version(int ver)
{
int bit;
if (ver == 0xffff)
return 0;
for (bit = 15; bit >= 0; bit--)
if (ver & (1<<bit))
return bit;
return 0;
}
static void
param_print(struct ata_params *parm)
{
printf("<%.40s/%.8s> ", parm->model, parm->revision);
if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
if (parm->satacapabilities & ATA_SATA_GEN2)
printf("SATA revision 2.x\n");
else if (parm->satacapabilities & ATA_SATA_GEN1)
printf("SATA revision 1.x\n");
else
printf("Unknown SATA revision\n");
}
else
printf("ATA/ATAPI revision %d\n", version(parm->version_major));
}
static void
cap_print(struct ata_params *parm)
{
u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
((u_int32_t)parm->lba_size_2 << 16);
u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
((u_int64_t)parm->lba_size48_2 << 16) |
((u_int64_t)parm->lba_size48_3 << 32) |
((u_int64_t)parm->lba_size48_4 << 48);
printf("\n");
printf("Protocol ");
if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
if (parm->satacapabilities & ATA_SATA_GEN2)
printf("SATA revision 2.x\n");
else if (parm->satacapabilities & ATA_SATA_GEN1)
printf("SATA revision 1.x\n");
else
printf("Unknown SATA revision\n");
}
else
printf("ATA/ATAPI revision %d\n", version(parm->version_major));
printf("device model %.40s\n", parm->model);
printf("serial number %.20s\n", parm->serial);
printf("firmware revision %.8s\n", parm->revision);
printf("cylinders %d\n", parm->cylinders);
printf("heads %d\n", parm->heads);
printf("sectors/track %d\n", parm->sectors);
if (parm->config == ATA_PROTO_CFA ||
(parm->support.command2 & ATA_SUPPORT_CFA))
printf("CFA supported\n");
printf("lba%ssupported ",
parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
if (lbasize)
printf("%d sectors\n", lbasize);
else
printf("\n");
printf("lba48%ssupported ",
parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
if (lbasize48)
printf("%ju sectors\n", (uintmax_t)lbasize48);
else
printf("\n");
printf("dma%ssupported\n",
parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
printf("overlap%ssupported\n",
parm->capabilities1 & ATA_SUPPORT_OVERLAP ? " " : " not ");
printf("\nFeature "
"Support Enable Value Vendor\n");
printf("write cache %s %s\n",
parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
printf("read ahead %s %s\n",
parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
printf("Native Command Queuing (NCQ) %s %s"
" %d/0x%02X\n",
parm->satacapabilities & ATA_SUPPORT_NCQ ?
"yes" : "no", " -",
(parm->satacapabilities & ATA_SUPPORT_NCQ) ?
ATA_QUEUE_LEN(parm->queue) : 0,
(parm->satacapabilities & ATA_SUPPORT_NCQ) ?
ATA_QUEUE_LEN(parm->queue) : 0);
}
printf("Tagged Command Queuing (TCQ) %s %s %d/0x%02X\n",
parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
ATA_QUEUE_LEN(parm->queue), ATA_QUEUE_LEN(parm->queue));
printf("SMART %s %s\n",
parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
printf("microcode download %s %s\n",
parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
printf("security %s %s\n",
parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
printf("power management %s %s\n",
parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
printf("advanced power management %s %s %d/0x%02X\n",
parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no",
parm->apm_value, parm->apm_value);
printf("automatic acoustic management %s %s "
"%d/0x%02X %d/0x%02X\n",
parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
ATA_ACOUSTIC_CURRENT(parm->acoustic),
ATA_ACOUSTIC_CURRENT(parm->acoustic),
ATA_ACOUSTIC_VENDOR(parm->acoustic),
ATA_ACOUSTIC_VENDOR(parm->acoustic));
}
static void
ata_cap_print(int fd)
{
struct ata_params params;
if (ioctl(fd, IOCATAGPARM, &params) < 0)
err(1, "ioctl(IOCATAGPARM)");
cap_print(&params);
}
static void
info_print(int fd, int channel, int prchan)
{
struct ata_ioc_devices devices;
devices.channel = channel;
if (ioctl(fd, IOCATADEVICES, &devices) < 0) {
if (!prchan)
err(1, "ioctl(IOCATADEVICES)");
return;
}
if (prchan)
printf("ATA channel %d:\n", channel);
printf("%sMaster: ", prchan ? " " : "");
if (*devices.name[0]) {
printf("%4.4s ", devices.name[0]);
param_print(&devices.params[0]);
}
else
printf(" no device present\n");
printf("%sSlave: ", prchan ? " " : "");
if (*devices.name[1]) {
printf("%4.4s ", devices.name[1]);
param_print(&devices.params[1]);
}
else
printf(" no device present\n");
}
static void
ata_spindown(int fd, const char *dev, const char *arg)
{
int tmo;
if (arg != NULL) {
tmo = strtoul(arg, NULL, 0);
if (ioctl(fd, IOCATASSPINDOWN, &tmo) < 0)
err(1, "ioctl(IOCATASSPINDOWN)");
} else {
if (ioctl(fd, IOCATAGSPINDOWN, &tmo) < 0)
err(1, "ioctl(IOCATAGSPINDOWN)");
if (tmo == 0)
printf("%s: idle spin down disabled\n", dev);
else
printf("%s: spin down after %d seconds idle\n",
dev, tmo);
}
}
static int
open_dev(const char *arg, int mode)
{
int disk, fd;
char device[64];
if (!(sscanf(arg, "ad%d", &disk) == 1 ||
sscanf(arg, "acd%d", &disk) == 1 ||
sscanf(arg, "afd%d", &disk) == 1 ||
sscanf(arg, "ast%d", &disk) == 1)) {
fprintf(stderr, "atacontrol: Invalid device %s\n", arg);
exit(EX_USAGE);
}
sprintf(device, "/dev/%s", arg);
if ((fd = open(device, mode)) < 0)
err(1, "device not found");
return (fd);
}
static int
ar_arg(const char *arg)
{
int array;
if (!(sscanf(arg, "ar%d", &array) == 1)) {
fprintf(stderr, "atacontrol: Invalid array %s\n", arg);
exit(EX_USAGE);
}
return (array);
}
static int
ata_arg(const char *arg)
{
int channel;
if (!(sscanf(arg, "ata%d", &channel) == 1)) {
fprintf(stderr, "atacontrol: Invalid channel %s\n", arg);
exit(EX_USAGE);
}
return (channel);
}
int
main(int argc, char **argv)
{
int fd, mode, channel, array;
if (feature_present("ata_cam")) {
errx(1, "\nATA_CAM option is enabled in kernel.\n"
"Please use camcontrol instead.");
}
if (argc < 2)
usage();
if (!strcmp(argv[1], "mode") && (argc == 3 || argc == 4)) {
fd = open_dev(argv[2], O_RDONLY);
if (argc == 4) {
mode = str2mode(argv[3]);
if (mode == -1)
errx(1, "unknown mode");
if (ioctl(fd, IOCATASMODE, &mode) < 0)
warn("ioctl(IOCATASMODE)");
}
if (argc == 3 || argc == 4) {
if (ioctl(fd, IOCATAGMODE, &mode) < 0)
err(1, "ioctl(IOCATAGMODE)");
printf("current mode = %s %s\n",
mode2str(mode), satarev2str(mode));
}
exit(EX_OK);
}
if (!strcmp(argv[1], "cap") && argc == 3) {
fd = open_dev(argv[2], O_RDONLY);
ata_cap_print(fd);
exit(EX_OK);
}
if (!strcmp(argv[1], "spindown") && (argc == 3 || argc == 4)) {
fd = open_dev(argv[2], O_RDONLY);
ata_spindown(fd, argv[2], argv[3]);
exit(EX_OK);
}
if ((fd = open("/dev/ata", O_RDWR)) < 0)
err(1, "control device not found");
if (!strcmp(argv[1], "list") && argc == 2) {
int maxchannel;
if (ioctl(fd, IOCATAGMAXCHANNEL, &maxchannel) < 0)
err(1, "ioctl(IOCATAGMAXCHANNEL)");
for (channel = 0; channel < maxchannel; channel++)
info_print(fd, channel, 1);
exit(EX_OK);
}
if (!strcmp(argv[1], "info") && argc == 3) {
channel = ata_arg(argv[2]);
info_print(fd, channel, 0);
exit(EX_OK);
}
if (!strcmp(argv[1], "detach") && argc == 3) {
channel = ata_arg(argv[2]);
if (ioctl(fd, IOCATADETACH, &channel) < 0)
err(1, "ioctl(IOCATADETACH)");
exit(EX_OK);
}
if (!strcmp(argv[1], "attach") && argc == 3) {
channel = ata_arg(argv[2]);
if (ioctl(fd, IOCATAATTACH, &channel) < 0)
err(1, "ioctl(IOCATAATTACH)");
info_print(fd, channel, 0);
exit(EX_OK);
}
if (!strcmp(argv[1], "reinit") && argc == 3) {
channel = ata_arg(argv[2]);
if (ioctl(fd, IOCATAREINIT, &channel) < 0)
warn("ioctl(IOCATAREINIT)");
info_print(fd, channel, 0);
exit(EX_OK);
}
if (!strcmp(argv[1], "create")) {
int disk, dev, offset;
struct ata_ioc_raid_config config;
bzero(&config, sizeof(config));
if (argc > 2) {
if (!strcasecmp(argv[2], "RAID0") ||
!strcasecmp(argv[2], "stripe"))
config.type = AR_RAID0;
if (!strcasecmp(argv[2], "RAID1") ||
!strcasecmp(argv[2],"mirror"))
config.type = AR_RAID1;
if (!strcasecmp(argv[2], "RAID0+1") ||
!strcasecmp(argv[2],"RAID10"))
config.type = AR_RAID01;
if (!strcasecmp(argv[2], "RAID5"))
config.type = AR_RAID5;
if (!strcasecmp(argv[2], "SPAN"))
config.type = AR_SPAN;
if (!strcasecmp(argv[2], "JBOD"))
config.type = AR_JBOD;
}
if (!config.type) {
fprintf(stderr, "atacontrol: Invalid RAID type %s\n",
argv[2]);
fprintf(stderr, "atacontrol: Valid RAID types: \n");
fprintf(stderr, " stripe | mirror | "
"RAID0 | RAID1 | RAID0+1 | RAID5 | "
"SPAN | JBOD\n");
exit(EX_USAGE);
}
if (config.type == AR_RAID0 ||
config.type == AR_RAID01 ||
config.type == AR_RAID5) {
if (argc < 4 ||
!sscanf(argv[3], "%d", &config.interleave) == 1) {
fprintf(stderr,
"atacontrol: Invalid interleave %s\n",
argv[3]);
exit(EX_USAGE);
}
offset = 4;
}
else
offset = 3;
for (disk = 0; disk < 16 && (offset + disk) < argc; disk++) {
if (!(sscanf(argv[offset + disk], "ad%d", &dev) == 1)) {
fprintf(stderr,
"atacontrol: Invalid disk %s\n",
argv[offset + disk]);
exit(EX_USAGE);
}
config.disks[disk] = dev;
}
if ((config.type == AR_RAID1 || config.type == AR_RAID01) &&
disk < 2) {
fprintf(stderr, "atacontrol: At least 2 disks must be "
"specified\n");
exit(EX_USAGE);
}
config.total_disks = disk;
if (ioctl(fd, IOCATARAIDCREATE, &config) < 0)
err(1, "ioctl(IOCATARAIDCREATE)");
else
printf("ar%d created\n", config.lun);
exit(EX_OK);
}
if (!strcmp(argv[1], "delete") && argc == 3) {
array = ar_arg(argv[2]);
if (ioctl(fd, IOCATARAIDDELETE, &array) < 0)
warn("ioctl(IOCATARAIDDELETE)");
exit(EX_OK);
}
if (!strcmp(argv[1], "addspare") && argc == 4) {
struct ata_ioc_raid_config config;
config.lun = ar_arg(argv[2]);
if (!(sscanf(argv[3], "ad%d", &config.disks[0]) == 1)) {
fprintf(stderr,
"atacontrol: Invalid disk %s\n", argv[3]);
usage();
}
if (ioctl(fd, IOCATARAIDADDSPARE, &config) < 0)
warn("ioctl(IOCATARAIDADDSPARE)");
exit(EX_OK);
}
if (!strcmp(argv[1], "rebuild") && argc == 3) {
array = ar_arg(argv[2]);
if (ioctl(fd, IOCATARAIDREBUILD, &array) < 0)
warn("ioctl(IOCATARAIDREBUILD)");
else {
char device[64];
char *buffer;
ssize_t len;
int arfd;
if (daemon(0, 1) == -1)
err(1, "daemon");
nice(20);
snprintf(device, sizeof(device), "/dev/ar%d",
array);
if ((arfd = open(device, O_RDONLY)) == -1)
err(1, "open %s", device);
if ((buffer = malloc(1024 * 1024)) == NULL)
err(1, "malloc");
while ((len = read(arfd, buffer, 1024 * 1024)) > 0)
;
if (len == -1)
err(1, "read");
else
fprintf(stderr,
"atacontrol: ar%d rebuild completed\n",
array);
free(buffer);
close(arfd);
}
exit(EX_OK);
}
if (!strcmp(argv[1], "status") && argc == 3) {
struct ata_ioc_raid_status status;
int i, lun, state;
status.lun = ar_arg(argv[2]);
if (ioctl(fd, IOCATARAIDSTATUS, &status) < 0)
err(1, "ioctl(IOCATARAIDSTATUS)");
printf("ar%d: ATA ", status.lun);
switch (status.type) {
case AR_RAID0:
printf("RAID0 stripesize=%d", status.interleave);
break;
case AR_RAID1:
printf("RAID1");
break;
case AR_RAID01:
printf("RAID0+1 stripesize=%d", status.interleave);
break;
case AR_RAID5:
printf("RAID5 stripesize=%d", status.interleave);
break;
case AR_JBOD:
printf("JBOD");
break;
case AR_SPAN:
printf("SPAN");
break;
}
printf(" status: ");
switch (status.status) {
case AR_READY:
printf("READY\n");
break;
case AR_READY | AR_DEGRADED:
printf("DEGRADED\n");
break;
case AR_READY | AR_DEGRADED | AR_REBUILDING:
printf("REBUILDING %d%% completed\n",
status.progress);
break;
default:
printf("BROKEN\n");
}
printf(" subdisks:\n");
for (i = 0; i < status.total_disks; i++) {
printf(" %2d ", i);
lun = status.disks[i].lun;
state = status.disks[i].state;
if (lun < 0)
printf("---- ");
else
printf("ad%-2d ", lun);
if (state & AR_DISK_ONLINE)
printf("ONLINE");
else if (state & AR_DISK_SPARE)
printf("SPARE");
else if (state & AR_DISK_PRESENT)
printf("OFFLINE");
else
printf("MISSING");
printf("\n");
}
exit(EX_OK);
}
usage();
exit(EX_OK);
}