7551d83c35
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
715 lines
20 KiB
C
715 lines
20 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include <fcntl.h>
|
|
#include <paths.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <err.h>
|
|
|
|
#include <dev/mlx/mlxio.h>
|
|
#include <dev/mlx/mlxreg.h>
|
|
|
|
#include "mlxcontrol.h"
|
|
|
|
static int cmd_status(int argc, char *argv[]);
|
|
static int cmd_rescan(int argc, char *argv[]);
|
|
static int cmd_detach(int argc, char *argv[]);
|
|
static int cmd_check(int argc, char *argv[]);
|
|
static int cmd_rebuild(int argc, char *argv[]);
|
|
#ifdef SUPPORT_PAUSE
|
|
static int cmd_pause(int argc, char *argv[]);
|
|
#endif
|
|
static int cmd_help(int argc, char *argv[]);
|
|
|
|
extern int cmd_config(int argc, char *argv[]);
|
|
|
|
|
|
struct
|
|
{
|
|
char *cmd;
|
|
int (*func)(int argc, char *argv[]);
|
|
char *desc;
|
|
char *text;
|
|
} commands[] = {
|
|
{"status", cmd_status,
|
|
"displays device status",
|
|
" status [-qv] [<drive>...]\n"
|
|
" Display status for <drive> or all drives if none is listed\n"
|
|
" -q Suppress output.\n"
|
|
" -v Display verbose information.\n"
|
|
" Returns 0 if all drives tested are online, 1 if one or more are\n"
|
|
" critical, and 2 if one or more are offline."},
|
|
{"rescan", cmd_rescan,
|
|
"scan for new system drives",
|
|
" rescan <controller> [<controller>...]\n"
|
|
" Rescan <controller> for system drives.\n"
|
|
" rescan -a\n"
|
|
" Rescan all controllers for system drives."},
|
|
{"detach", cmd_detach,
|
|
"detach system drives",
|
|
" detach <drive> [<drive>...]\n"
|
|
" Detaches <drive> from the controller.\n"
|
|
" detach -a <controller>\n"
|
|
" Detaches all drives on <controller>."},
|
|
{"check", cmd_check,
|
|
"consistency-check a system drive",
|
|
" check <drive>\n"
|
|
" Requests a check and rebuild of the parity information on <drive>.\n"
|
|
" Note that each controller can only check one system drive at a time."},
|
|
{"rebuild", cmd_rebuild,
|
|
"initiate a rebuild of a dead physical drive",
|
|
" rebuild <controller> <physdrive>\n"
|
|
" All system drives using space on the physical drive <physdrive>\n"
|
|
" are rebuilt, reconstructing all data on the drive.\n"
|
|
" Note that each controller can only perform one rebuild at a time."},
|
|
#ifdef SUPPORT_PAUSE
|
|
{"pause", cmd_pause,
|
|
"pauses controller channels",
|
|
" pause [-t <howlong>] [-d <delay>] <controller> [<channel>...]\n"
|
|
" Pauses SCSI I/O on <channel> and <controller>. If no channel is specified,\n"
|
|
" all channels are paused.\n"
|
|
" <howlong> How long (seconds) to pause for (default 30).\n"
|
|
" <delay> How long (seconds) to wait before pausing (default 30).\n"
|
|
" pause <controller> -c\n"
|
|
" Cancels any pending pause operation on <controller>."},
|
|
#endif
|
|
{"config", cmd_config,
|
|
"examine and update controller configuration",
|
|
" config <controller>\n"
|
|
" Print configuration for <controller>."},
|
|
{"help", cmd_help,
|
|
"give help on usage",
|
|
""},
|
|
{NULL, NULL, NULL, NULL}
|
|
};
|
|
|
|
/********************************************************************************
|
|
* Command dispatch and global options parsing.
|
|
*/
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int ch, i, oargc;
|
|
char **oargv;
|
|
|
|
oargc = argc;
|
|
oargv = argv;
|
|
while ((ch = getopt(argc, argv, "")) != -1)
|
|
switch(ch) {
|
|
default:
|
|
return(cmd_help(0, NULL));
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc > 0)
|
|
for (i = 0; commands[i].cmd != NULL; i++)
|
|
if (!strcmp(argv[0], commands[i].cmd))
|
|
return(commands[i].func(argc, argv));
|
|
|
|
return(cmd_help(oargc, oargv));
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Helptext output
|
|
*/
|
|
static int
|
|
cmd_help(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
|
|
if (argc > 1)
|
|
for (i = 0; commands[i].cmd != NULL; i++)
|
|
if (!strcmp(argv[1], commands[i].cmd)) {
|
|
fprintf(stderr, "%s\n", commands[i].text);
|
|
fflush(stderr);
|
|
return(0);
|
|
}
|
|
|
|
if (argv != NULL)
|
|
fprintf(stderr, "Unknown command '%s'.\n", argv[1]);
|
|
fprintf(stderr, "Valid commands are:\n");
|
|
for (i = 0; commands[i].cmd != NULL; i++)
|
|
fprintf(stderr, " %-20s %s\n", commands[i].cmd, commands[i].desc);
|
|
fflush(stderr);
|
|
return(0);
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Status output
|
|
*
|
|
* status [-qv] [<device> ...]
|
|
* Prints status for <device>, or all if none listed.
|
|
*
|
|
* -q Suppresses output, command returns 0 if devices are OK, 1 if one or
|
|
* more devices are critical, 2 if one or more devices are offline.
|
|
*/
|
|
static struct mlx_rebuild_status rs;
|
|
static int rs_ctrlr = -1;
|
|
static int status_result = 0;
|
|
|
|
/* XXX more verbosity! */
|
|
static void
|
|
status_print(int unit, void *arg)
|
|
{
|
|
int verbosity = *(int *)arg;
|
|
int fd, result, ctrlr, sysdrive, statvalid;
|
|
|
|
/* Find which controller and what system drive we are */
|
|
statvalid = 0;
|
|
if (mlxd_find_ctrlr(unit, &ctrlr, &sysdrive)) {
|
|
warnx("couldn't get controller/drive for %s", drivepath(unit));
|
|
} else {
|
|
/* If we don't have rebuild stats for this controller, get them */
|
|
if (rs_ctrlr == ctrlr) {
|
|
statvalid = 1;
|
|
} else {
|
|
if ((fd = open(ctrlrpath(ctrlr), 0)) < 0) {
|
|
warn("can't open %s", ctrlrpath(ctrlr));
|
|
} else {
|
|
if (ioctl(fd, MLX_REBUILDSTAT, &rs) < 0) {
|
|
warn("ioctl MLX_REBUILDSTAT");
|
|
} else {
|
|
rs_ctrlr = ctrlr;
|
|
statvalid = 1;
|
|
}
|
|
close(fd);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Get the device */
|
|
if ((fd = open(drivepath(unit), 0)) < 0) {
|
|
warn("can't open %s", drivepath(unit));
|
|
return;
|
|
}
|
|
|
|
/* Get its status */
|
|
if (ioctl(fd, MLXD_STATUS, &result) < 0) {
|
|
warn("ioctl MLXD_STATUS");
|
|
} else {
|
|
switch(result) {
|
|
case MLX_SYSD_ONLINE:
|
|
if (verbosity > 0)
|
|
printf("%s: online", drivename(unit));
|
|
break;
|
|
case MLX_SYSD_CRITICAL:
|
|
if (verbosity > 0)
|
|
printf("%s: critical", drivename(unit));
|
|
if (status_result < 1)
|
|
status_result = 1;
|
|
break;
|
|
case MLX_SYSD_OFFLINE:
|
|
if (verbosity > 0)
|
|
printf("%s: offline", drivename(unit));
|
|
if (status_result < 2)
|
|
status_result = 2;
|
|
break;
|
|
default:
|
|
if (verbosity > 0) {
|
|
printf("%s: unknown status 0x%x", drivename(unit), result);
|
|
}
|
|
}
|
|
if (verbosity > 0) {
|
|
/* rebuild/check in progress on this drive? */
|
|
if (statvalid && (rs_ctrlr == ctrlr) &&
|
|
(rs.rs_drive == sysdrive) && (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");
|
|
}
|
|
printf(": %d/%d, %d%% complete]",
|
|
rs.rs_remaining, rs.rs_size,
|
|
((rs.rs_size - rs.rs_remaining) / (rs.rs_size / 100)));
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
close(fd);
|
|
}
|
|
|
|
static struct
|
|
{
|
|
int hwid;
|
|
char *name;
|
|
} mlx_controller_names[] = {
|
|
{0x01, "960P/PD"},
|
|
{0x02, "960PL"},
|
|
{0x10, "960PG"},
|
|
{0x11, "960PJ"},
|
|
{0x12, "960PR"},
|
|
{0x13, "960PT"},
|
|
{0x14, "960PTL0"},
|
|
{0x15, "960PRL"},
|
|
{0x16, "960PTL1"},
|
|
{0x20, "1100PVX"},
|
|
{-1, NULL}
|
|
};
|
|
|
|
static void
|
|
controller_print(int unit, void *arg)
|
|
{
|
|
struct mlx_enquiry2 enq;
|
|
struct mlx_phys_drv pd;
|
|
int verbosity = *(int *)arg;
|
|
static char buf[80];
|
|
char *model;
|
|
int i, channel, target;
|
|
|
|
if (verbosity == 0)
|
|
return;
|
|
|
|
/* fetch and print controller data */
|
|
if (mlx_enquiry(unit, &enq)) {
|
|
printf("mlx%d: error submitting ENQUIRY2\n", unit);
|
|
} else {
|
|
|
|
for (i = 0, model = NULL; mlx_controller_names[i].name != NULL; i++) {
|
|
if ((enq.me_hardware_id & 0xff) == mlx_controller_names[i].hwid) {
|
|
model = mlx_controller_names[i].name;
|
|
break;
|
|
}
|
|
}
|
|
if (model == NULL) {
|
|
sprintf(buf, " model 0x%x", enq.me_hardware_id & 0xff);
|
|
model = buf;
|
|
}
|
|
|
|
printf("mlx%d: DAC%s, %d channel%s, firmware %d.%02d-%c-%02d, %dMB RAM\n",
|
|
unit, model,
|
|
enq.me_actual_channels,
|
|
enq.me_actual_channels > 1 ? "s" : "",
|
|
enq.me_firmware_id & 0xff,
|
|
(enq.me_firmware_id >> 8) & 0xff,
|
|
(enq.me_firmware_id >> 16),
|
|
(enq.me_firmware_id >> 24) & 0xff,
|
|
enq.me_mem_size / (1024 * 1024));
|
|
|
|
if (verbosity > 1) {
|
|
printf(" Hardware ID 0x%08x\n", enq.me_hardware_id);
|
|
printf(" Firmware ID 0x%08x\n", enq.me_firmware_id);
|
|
printf(" Configured/Actual channels %d/%d\n", enq.me_configured_channels,
|
|
enq.me_actual_channels);
|
|
printf(" Max Targets %d\n", enq.me_max_targets);
|
|
printf(" Max Tags %d\n", enq.me_max_tags);
|
|
printf(" Max System Drives %d\n", enq.me_max_sys_drives);
|
|
printf(" Max Arms %d\n", enq.me_max_arms);
|
|
printf(" Max Spans %d\n", enq.me_max_spans);
|
|
printf(" DRAM/cache/flash/NVRAM size %d/%d/%d/%d\n", enq.me_mem_size,
|
|
enq.me_cache_size, enq.me_flash_size, enq.me_nvram_size);
|
|
printf(" DRAM type %d\n", enq.me_mem_type);
|
|
printf(" Clock Speed %dns\n", enq.me_clock_speed);
|
|
printf(" Hardware Speed %dns\n", enq.me_hardware_speed);
|
|
printf(" Max Commands %d\n", enq.me_max_commands);
|
|
printf(" Max SG Entries %d\n", enq.me_max_sg);
|
|
printf(" Max DP %d\n", enq.me_max_dp);
|
|
printf(" Max IOD %d\n", enq.me_max_iod);
|
|
printf(" Max Comb %d\n", enq.me_max_comb);
|
|
printf(" Latency %ds\n", enq.me_latency);
|
|
printf(" SCSI Timeout %ds\n", enq.me_scsi_timeout);
|
|
printf(" Min Free Lines %d\n", enq.me_min_freelines);
|
|
printf(" Rate Constant %d\n", enq.me_rate_const);
|
|
printf(" MAXBLK %d\n", enq.me_maxblk);
|
|
printf(" Blocking Factor %d sectors\n", enq.me_blocking_factor);
|
|
printf(" Cache Line Size %d blocks\n", enq.me_cacheline);
|
|
printf(" SCSI Capability %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 %d\n", enq.me_firmware_build);
|
|
printf(" Fault Management Type %d\n", enq.me_fault_mgmt_type);
|
|
#if 0
|
|
printf(" Features %b\n", enq.me_firmware_features,
|
|
"\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
|
|
#endif
|
|
}
|
|
|
|
/* 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(unit, channel, target, &pd) == 0) &&
|
|
(pd.pd_flags1 & MLX_PHYS_DRV_PRESENT)) {
|
|
mlx_print_phys_drv(&pd, channel, target, " ", verbosity - 1);
|
|
if (verbosity > 1) {
|
|
/* XXX print device statistics? */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
cmd_status(int argc, char *argv[])
|
|
{
|
|
int ch, verbosity = 1, i, unit;
|
|
|
|
optreset = 1;
|
|
optind = 1;
|
|
while ((ch = getopt(argc, argv, "qv")) != -1)
|
|
switch(ch) {
|
|
case 'q':
|
|
verbosity = 0;
|
|
break;
|
|
case 'v':
|
|
verbosity = 2;
|
|
break;
|
|
default:
|
|
return(cmd_help(argc, argv));
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc < 1) {
|
|
mlx_foreach(controller_print, &verbosity);
|
|
mlxd_foreach(status_print, &verbosity);
|
|
} else {
|
|
for (i = 0; i < argc; i++) {
|
|
if ((unit = driveunit(argv[i])) == -1) {
|
|
warnx("'%s' is not a valid drive", argv[i]);
|
|
} else {
|
|
status_print(unit, &verbosity);
|
|
}
|
|
}
|
|
}
|
|
return(status_result);
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Recscan for system drives on one or more controllers.
|
|
*
|
|
* rescan <controller> [<controller>...]
|
|
* rescan -a
|
|
*/
|
|
static void
|
|
rescan_ctrlr(int unit, void *junk)
|
|
{
|
|
int fd;
|
|
|
|
/* Get the device */
|
|
if ((fd = open(ctrlrpath(unit), 0)) < 0) {
|
|
warn("can't open %s", ctrlrpath(unit));
|
|
return;
|
|
}
|
|
|
|
if (ioctl(fd, MLX_RESCAN_DRIVES) < 0)
|
|
warn("can't rescan %s", ctrlrname(unit));
|
|
close(fd);
|
|
}
|
|
|
|
static int
|
|
cmd_rescan(int argc, char *argv[])
|
|
{
|
|
int all = 0, i, ch, unit;
|
|
|
|
optreset = 1;
|
|
optind = 1;
|
|
while ((ch = getopt(argc, argv, "a")) != -1)
|
|
switch(ch) {
|
|
case 'a':
|
|
all = 1;
|
|
break;
|
|
default:
|
|
return(cmd_help(argc, argv));
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (all) {
|
|
mlx_foreach(rescan_ctrlr, NULL);
|
|
} else {
|
|
for (i = 0; i < argc; i++) {
|
|
if ((unit = ctrlrunit(argv[i])) == -1) {
|
|
warnx("'%s' is not a valid controller", argv[i]);
|
|
} else {
|
|
rescan_ctrlr(unit, NULL);
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Detach one or more system drives from a controller.
|
|
*
|
|
* detach <drive> [<drive>...]
|
|
* Detach <drive>.
|
|
*
|
|
* detach -a <controller> [<controller>...]
|
|
* Detach all drives on <controller>.
|
|
*
|
|
*/
|
|
static void
|
|
detach_drive(int unit, void *arg)
|
|
{
|
|
int fd;
|
|
|
|
/* Get the device */
|
|
if ((fd = open(ctrlrpath(unit), 0)) < 0) {
|
|
warn("can't open %s", ctrlrpath(unit));
|
|
return;
|
|
}
|
|
|
|
if (ioctl(fd, MLX_DETACH_DRIVE, &unit) < 0)
|
|
warn("can't detach %s", drivename(unit));
|
|
close(fd);
|
|
}
|
|
|
|
static int
|
|
cmd_detach(int argc, char *argv[])
|
|
{
|
|
struct mlxd_foreach_action ma;
|
|
int all = 0, i, ch, unit;
|
|
|
|
optreset = 1;
|
|
optind = 1;
|
|
while ((ch = getopt(argc, argv, "a")) != -1)
|
|
switch(ch) {
|
|
case 'a':
|
|
all = 1;
|
|
break;
|
|
default:
|
|
return(cmd_help(argc, argv));
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (all) {
|
|
ma.func = detach_drive;
|
|
ma.arg = &unit;
|
|
for (i = 0; i < argc; i++) {
|
|
if ((unit = ctrlrunit(argv[i])) == -1) {
|
|
warnx("'%s' is not a valid controller", argv[i]);
|
|
} else {
|
|
mlxd_foreach_ctrlr(unit, &ma);
|
|
}
|
|
}
|
|
} else {
|
|
for (i = 0; i < argc; i++) {
|
|
if ((unit = driveunit(argv[i])) == -1) {
|
|
warnx("'%s' is not a valid drive", argv[i]);
|
|
} else {
|
|
/* run across all controllers to find this drive */
|
|
mlx_foreach(detach_drive, &unit);
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Initiate a consistency check on a system drive.
|
|
*
|
|
* check [<drive>]
|
|
* Start a check of <drive>
|
|
*
|
|
*/
|
|
static int
|
|
cmd_check(int argc, char *argv[])
|
|
{
|
|
int unit, fd, result;
|
|
|
|
if (argc != 2)
|
|
return(cmd_help(argc, argv));
|
|
|
|
if ((unit = driveunit(argv[1])) == -1) {
|
|
warnx("'%s' is not a valid drive", argv[1]);
|
|
} else {
|
|
|
|
/* Get the device */
|
|
if ((fd = open(drivepath(unit), 0)) < 0) {
|
|
warn("can't open %s", drivepath(unit));
|
|
} else {
|
|
/* Try to start the check */
|
|
if ((ioctl(fd, MLXD_CHECKASYNC, &result)) < 0) {
|
|
switch(result) {
|
|
case 0x0002:
|
|
warnx("one or more of the SCSI disks on which the drive '%s' depends is DEAD", argv[1]);
|
|
break;
|
|
case 0x0105:
|
|
warnx("drive %s is invalid, or not a drive which can be checked", argv[1]);
|
|
break;
|
|
case 0x0106:
|
|
warnx("drive rebuild or consistency check is already in progress on this controller");
|
|
break;
|
|
default:
|
|
warn("ioctl MLXD_CHECKASYNC");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Initiate a physical drive rebuild
|
|
*
|
|
* rebuild <controller> <channel>:<target>
|
|
* Start a rebuild of <controller>:<channel>:<target>
|
|
*
|
|
*/
|
|
static int
|
|
cmd_rebuild(int argc, char *argv[])
|
|
{
|
|
struct mlx_rebuild_request rb;
|
|
int unit, fd;
|
|
|
|
if (argc != 3)
|
|
return(cmd_help(argc, argv));
|
|
|
|
/* parse arguments */
|
|
if ((unit = ctrlrunit(argv[1])) == -1) {
|
|
warnx("'%s' is not a valid controller", argv[1]);
|
|
return(1);
|
|
}
|
|
/* try diskXXXX and unknownXXXX as we report the latter for a dead drive ... */
|
|
if ((sscanf(argv[2], "disk%2d%2d", &rb.rr_channel, &rb.rr_target) != 2) &&
|
|
(sscanf(argv[2], "unknown%2d%2d", &rb.rr_channel, &rb.rr_target) != 2)) {
|
|
warnx("'%s' is not a valid physical drive", argv[2]);
|
|
return(1);
|
|
}
|
|
/* get the device */
|
|
if ((fd = open(ctrlrpath(unit), 0)) < 0) {
|
|
warn("can't open %s", ctrlrpath(unit));
|
|
return(1);
|
|
}
|
|
/* try to start the rebuild */
|
|
if ((ioctl(fd, MLX_REBUILDASYNC, &rb)) < 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 channel %d, target %d", rb.rr_channel, rb.rr_target);
|
|
break;
|
|
case 0x0106:
|
|
warnx("drive rebuild or consistency check is already in progress on this controller");
|
|
break;
|
|
default:
|
|
warn("ioctl MLXD_REBUILDASYNC");
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
#ifdef SUPPORT_PAUSE
|
|
/********************************************************************************
|
|
* Pause one or more channels on a controller
|
|
*
|
|
* pause [-d <delay>] [-t <time>] <controller> [<channel>...]
|
|
* Pauses <channel> (or all channels) for <time> seconds after a
|
|
* delay of <delay> seconds.
|
|
* pause <controller> -c
|
|
* Cancels pending pause
|
|
*/
|
|
static int
|
|
cmd_pause(int argc, char *argv[])
|
|
{
|
|
struct mlx_pause mp;
|
|
int unit, i, ch, fd, cancel = 0;
|
|
char *cp;
|
|
int oargc = argc;
|
|
char **oargv = argv;
|
|
|
|
mp.mp_which = 0;
|
|
mp.mp_when = 30;
|
|
mp.mp_howlong = 30;
|
|
optreset = 1;
|
|
optind = 1;
|
|
while ((ch = getopt(argc, argv, "cd:t:")) != -1)
|
|
switch(ch) {
|
|
case 'c':
|
|
cancel = 1;
|
|
break;
|
|
case 'd':
|
|
mp.mp_when = strtol(optarg, &cp, 0);
|
|
if (*cp != 0)
|
|
return(cmd_help(argc, argv));
|
|
break;
|
|
case 't':
|
|
mp.mp_howlong = strtol(optarg, &cp, 0);
|
|
if (*cp != 0)
|
|
return(cmd_help(argc, argv));
|
|
break;
|
|
default:
|
|
return(cmd_help(argc, argv));
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
/* get controller unit number that we're working on */
|
|
if ((argc < 1) || ((unit = ctrlrunit(argv[0])) == -1))
|
|
return(cmd_help(oargc, oargv));
|
|
|
|
/* Get the device */
|
|
if ((fd = open(ctrlrpath(unit), 0)) < 0) {
|
|
warn("can't open %s", ctrlrpath(unit));
|
|
return(1);
|
|
}
|
|
|
|
if (argc == 1) {
|
|
/* controller-wide pause/cancel */
|
|
mp.mp_which = cancel ? MLX_PAUSE_CANCEL : MLX_PAUSE_ALL;
|
|
} else {
|
|
for (i = 1; i < argc; i++) {
|
|
ch = strtol(argv[i], &cp, 0);
|
|
if (*cp != 0) {
|
|
warnx("bad channel number '%s'", argv[i]);
|
|
continue;
|
|
} else {
|
|
mp.mp_which |= (1 << ch);
|
|
}
|
|
}
|
|
}
|
|
if ((ioctl(fd, MLX_PAUSE_CHANNEL, &mp)) < 0)
|
|
warn("couldn't %s %s", cancel ? "cancel pause on" : "pause", ctrlrname(unit));
|
|
close(fd);
|
|
return(0);
|
|
}
|
|
#endif /* SUPPORT_PAUSE */
|
|
|