416 lines
11 KiB
C
416 lines
11 KiB
C
/* $NetBSD: cmds.c,v 1.11 2008/04/28 20:24:17 martin Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2001 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Andrew Doran.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*-
|
|
* Copyright (c) 1999 Michael Smith
|
|
* 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.
|
|
* 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 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 AUTHOR 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.
|
|
*
|
|
* from FreeBSD: command.c,v 1.2 2000/04/11 23:04:17 msmith Exp
|
|
*/
|
|
|
|
#ifndef lint
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: cmds.c,v 1.11 2008/04/28 20:24:17 martin Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/endian.h>
|
|
|
|
#include <dev/ic/mlxreg.h>
|
|
#include <dev/ic/mlxio.h>
|
|
|
|
#include <err.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "extern.h"
|
|
|
|
static void cmd_status0(struct mlx_disk *);
|
|
static void cmd_check0(struct mlx_disk *);
|
|
static void cmd_detach0(struct mlx_disk *);
|
|
|
|
static struct mlx_rebuild_status rs;
|
|
static int rstatus;
|
|
|
|
struct {
|
|
int hwid;
|
|
const char *name;
|
|
} static const mlx_ctlr_names[] = {
|
|
{ 0x00, "960E/960M" },
|
|
{ 0x01, "960P/PD" },
|
|
{ 0x02, "960PL" },
|
|
{ 0x10, "960PG" },
|
|
{ 0x11, "960PJ" },
|
|
{ 0x12, "960PR" },
|
|
{ 0x13, "960PT" },
|
|
{ 0x14, "960PTL0" },
|
|
{ 0x15, "960PRL" } ,
|
|
{ 0x16, "960PTL1" },
|
|
{ 0x20, "1100PVX" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
/*
|
|
* Status output
|
|
*/
|
|
static void
|
|
cmd_status0(struct mlx_disk *md)
|
|
{
|
|
int result;
|
|
|
|
result = md->hwunit;
|
|
if (ioctl(mlxfd, MLXD_STATUS, &result) < 0)
|
|
err(EXIT_FAILURE, "ioctl(MLXD_STATUS)");
|
|
|
|
switch(result) {
|
|
case MLX_SYSD_ONLINE:
|
|
printf("%s: online\n", md->name);
|
|
break;
|
|
|
|
case MLX_SYSD_CRITICAL:
|
|
printf("%s: critical\n", md->name);
|
|
if (!rstatus)
|
|
rstatus = 1;
|
|
break;
|
|
|
|
case MLX_SYSD_OFFLINE:
|
|
printf("%s: offline\n", md->name);
|
|
rstatus = 2;
|
|
break;
|
|
|
|
default:
|
|
printf("%s: unknown status 0x%02x\n", md->name, result);
|
|
break;
|
|
}
|
|
|
|
/* Rebuild/check in progress on this drive? */
|
|
if (rs.rs_drive == md->hwunit &&
|
|
rs.rs_code != MLX_REBUILDSTAT_IDLE) {
|
|
switch(rs.rs_code) {
|
|
case MLX_REBUILDSTAT_REBUILDCHECK:
|
|
printf(" [consistency check");
|
|
break;
|
|
|
|
case MLX_REBUILDSTAT_ADDCAPACITY:
|
|
printf(" [add capacity");
|
|
break;
|
|
|
|
case MLX_REBUILDSTAT_ADDCAPACITYINIT:
|
|
printf(" [add capacity init");
|
|
break;
|
|
|
|
default:
|
|
printf(" [unknown operation");
|
|
break;
|
|
}
|
|
|
|
printf(": %d/%d, %d%% complete]\n", rs.rs_remaining, rs.rs_size,
|
|
((rs.rs_size - rs.rs_remaining) / (rs.rs_size / 100)));
|
|
}
|
|
}
|
|
|
|
int
|
|
cmd_status(char **argv)
|
|
{
|
|
|
|
if (ioctl(mlxfd, MLX_REBUILDSTAT, &rs) < 0)
|
|
err(EXIT_FAILURE, "ioctl(MLX_REBUILDSTAT)");
|
|
|
|
mlx_disk_iterate(cmd_status0);
|
|
return (rstatus);
|
|
}
|
|
|
|
/*
|
|
* Display controller status.
|
|
*/
|
|
int
|
|
cmd_cstatus(char **argv)
|
|
{
|
|
struct mlx_enquiry2 enq;
|
|
struct mlx_phys_drv pd;
|
|
static char buf[80];
|
|
const char *model;
|
|
int i, channel, target;
|
|
|
|
model = NULL; /* XXXGCC -Wuninitialized */
|
|
|
|
for (i = 0; i < sizeof(mlx_ctlr_names) / sizeof(mlx_ctlr_names[0]); i++)
|
|
if (ci.ci_hardware_id == mlx_ctlr_names[i].hwid) {
|
|
model = mlx_ctlr_names[i].name;
|
|
break;
|
|
}
|
|
|
|
if (i == sizeof(mlx_ctlr_names) / sizeof(mlx_ctlr_names[0])) {
|
|
snprintf(buf, sizeof(buf), " model 0x%x", ci.ci_hardware_id);
|
|
model = buf;
|
|
}
|
|
|
|
printf("DAC%s, %d channel%s, firmware %d.%02d-%c-%02d",
|
|
model, ci.ci_nchan,
|
|
ci.ci_nchan > 1 ? "s" : "",
|
|
ci.ci_firmware_id[0], ci.ci_firmware_id[1],
|
|
ci.ci_firmware_id[3], ci.ci_firmware_id[2]);
|
|
if (ci.ci_mem_size != 0)
|
|
printf(", %dMB RAM", ci.ci_mem_size >> 20);
|
|
printf("\n");
|
|
|
|
if (verbosity > 0 && ci.ci_iftype > 1) {
|
|
mlx_enquiry(&enq);
|
|
|
|
printf(" Hardware ID\t\t\t0x%08x\n",
|
|
le32toh(*(u_int32_t *)enq.me_hardware_id));
|
|
printf(" Firmware ID\t\t\t0x%08x\n",
|
|
le32toh(*(u_int32_t *)enq.me_firmware_id));
|
|
printf(" Configured/Actual channels\t%d/%d\n",
|
|
enq.me_configured_channels, enq.me_actual_channels);
|
|
printf(" Max Targets\t\t\t%d\n", enq.me_max_targets);
|
|
printf(" Max Tags\t\t\t%d\n", enq.me_max_tags);
|
|
printf(" Max System Drives\t\t%d\n", enq.me_max_sys_drives);
|
|
printf(" Max Arms\t\t\t%d\n", enq.me_max_arms);
|
|
printf(" Max Spans\t\t\t%d\n", enq.me_max_spans);
|
|
printf(" DRAM/cache/flash/NVRAM size\t%d/%d/%d/%d\n",
|
|
le32toh(enq.me_mem_size), le32toh(enq.me_cache_size),
|
|
le32toh(enq.me_flash_size), le32toh(enq.me_nvram_size));
|
|
printf(" DRAM type\t\t\t%d\n", le16toh(enq.me_mem_type));
|
|
printf(" Clock Speed\t\t\t%dns\n",
|
|
le16toh(enq.me_clock_speed));
|
|
printf(" Hardware Speed\t\t%dns\n",
|
|
le16toh(enq.me_hardware_speed));
|
|
printf(" Max Commands\t\t\t%d\n",
|
|
le16toh(enq.me_max_commands));
|
|
printf(" Max SG Entries\t\t%d\n", le16toh(enq.me_max_sg));
|
|
printf(" Max DP\t\t\t%d\n", le16toh(enq.me_max_dp));
|
|
printf(" Max IOD\t\t\t%d\n", le16toh(enq.me_max_iod));
|
|
printf(" Max Comb\t\t\t%d\n", le16toh(enq.me_max_comb));
|
|
printf(" Latency\t\t\t%ds\n", enq.me_latency);
|
|
printf(" SCSI Timeout\t\t\t%ds\n", enq.me_scsi_timeout);
|
|
printf(" Min Free Lines\t\t%d\n",
|
|
le16toh(enq.me_min_freelines));
|
|
printf(" Rate Constant\t\t\t%d\n", enq.me_rate_const);
|
|
printf(" MAXBLK\t\t\t%d\n", le16toh(enq.me_maxblk));
|
|
printf(" Blocking Factor\t\t%d sectors\n",
|
|
le16toh(enq.me_blocking_factor));
|
|
printf(" Cache Line Size\t\t%d blocks\n",
|
|
le16toh(enq.me_cacheline));
|
|
printf(" SCSI Capability\t\t%s%dMHz, %d bit\n",
|
|
enq.me_scsi_cap & (1<<4) ? "differential " : "",
|
|
(1 << ((enq.me_scsi_cap >> 2) & 3)) * 10,
|
|
8 << (enq.me_scsi_cap & 0x3));
|
|
printf(" Firmware Build Number\t\t%d\n",
|
|
le16toh(enq.me_firmware_build));
|
|
printf(" Fault Management Type\t\t%d\n",
|
|
enq.me_fault_mgmt_type);
|
|
#if 0
|
|
printf(" Features\t\t\t%b\n", enq.me_firmware_features,
|
|
"\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
|
|
#endif
|
|
} else if (verbosity > 0 && ci.ci_iftype == 1)
|
|
warnx("can't be verbose for this firmware level");
|
|
|
|
fflush(stdout);
|
|
|
|
if (ci.ci_firmware_id[0] < 3) {
|
|
warnx("can't display physical drives for this firmware level");
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Fetch and print physical drive data.
|
|
*/
|
|
for (channel = 0; channel < enq.me_configured_channels; channel++) {
|
|
for (target = 0; target < enq.me_max_targets; target++)
|
|
if (mlx_get_device_state(channel, target, &pd) == 0 &&
|
|
(pd.pd_flags1 & MLX_PHYS_DRV_PRESENT) != 0)
|
|
mlx_print_phys_drv(&pd, channel, target, " ");
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Recscan for new or changed system drives.
|
|
*/
|
|
int
|
|
cmd_rescan(char **argv)
|
|
{
|
|
|
|
if (ioctl(mlxfd, MLX_RESCAN_DRIVES) < 0)
|
|
err(EXIT_FAILURE, "rescan failed");
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Detach one or more system drives from a controller.
|
|
*/
|
|
static void
|
|
cmd_detach0(struct mlx_disk *md)
|
|
{
|
|
|
|
if (ioctl(mlxfd, MLXD_DETACH, &md->hwunit) < 0)
|
|
warn("can't detach %s", md->name);
|
|
}
|
|
|
|
int
|
|
cmd_detach(char **argv)
|
|
{
|
|
|
|
mlx_disk_iterate(cmd_detach0);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Initiate a consistency check on a system drive.
|
|
*/
|
|
static void
|
|
cmd_check0(struct mlx_disk *md)
|
|
{
|
|
int result;
|
|
|
|
if (ioctl(mlxfd, MLXD_CHECKASYNC, &result) == 0)
|
|
return;
|
|
|
|
switch (result) {
|
|
case 0x0002:
|
|
warnx("one or more of the SCSI disks on which %s", md->name);
|
|
warnx("depends is DEAD.");
|
|
break;
|
|
|
|
case 0x0105:
|
|
warnx("drive %s is invalid, or not a drive which ", md->name);
|
|
warnx("can be checked.");
|
|
break;
|
|
|
|
case 0x0106:
|
|
warnx("drive rebuild or consistency check is already ");
|
|
warnx("in progress on this controller.");
|
|
break;
|
|
|
|
default:
|
|
err(EXIT_FAILURE, "ioctl(MLXD_CHECKASYNC)");
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
|
|
int
|
|
cmd_check(char **argv)
|
|
{
|
|
|
|
if (ci.ci_firmware_id[0] < 3) {
|
|
warnx("action not supported by this firmware version");
|
|
return (1);
|
|
}
|
|
|
|
mlx_disk_iterate(cmd_check0);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Initiate a physical drive rebuild.
|
|
*/
|
|
int
|
|
cmd_rebuild(char **argv)
|
|
{
|
|
struct mlx_rebuild_request rb;
|
|
char *p;
|
|
|
|
if (ci.ci_firmware_id[0] < 3) {
|
|
warnx("action not supported by this firmware version");
|
|
return (1);
|
|
}
|
|
|
|
if (argv[0] == NULL || argv[1] != NULL)
|
|
usage();
|
|
|
|
rb.rr_channel = (int)strtol(*argv, &p, 0);
|
|
if (p[0] != ':' || p[1] == '\0')
|
|
usage();
|
|
|
|
rb.rr_target = (int)strtol(*argv, &p, 0);
|
|
if (p[0] != '\0')
|
|
usage();
|
|
|
|
if (ioctl(mlxfd, MLX_REBUILDASYNC, &rb) == 0)
|
|
return (0);
|
|
|
|
switch (rb.rr_status) {
|
|
case 0x0002:
|
|
warnx("the drive at %d:%d is already ONLINE", rb.rr_channel,
|
|
rb.rr_target);
|
|
break;
|
|
|
|
case 0x0004:
|
|
warnx("drive failed during rebuild");
|
|
break;
|
|
|
|
case 0x0105:
|
|
warnx("there is no drive at %d:%d", rb.rr_channel,
|
|
rb.rr_target);
|
|
break;
|
|
|
|
case 0x0106:
|
|
warnx("drive rebuild or consistency check is already in ");
|
|
warnx("progress on this controller");
|
|
break;
|
|
|
|
default:
|
|
err(EXIT_FAILURE, "ioctl(MLXD_CHECKASYNC)");
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
return(0);
|
|
}
|