Add mptutil, a basic utility for managing MPT SCSI/SATA/SAS controllers.

Drive and controller status can be reported, basic attributes changed,
and arrays and spares can be created and deleted.

Approved by:	re
Obtained from:	Yahoo! Inc.

1 files changed, 1160 insertions, 0 deletions

diff --git a/usr.sbin/mptutil/mpt_config.c b/usr.sbin/mptutil/mpt_config.c
new file mode 100644
index 000000000000..3874df301379
--- /dev/null
+++ b/usr.sbin/mptutil/mpt_config.c
@@ -0,0 +1,1160 @@
+/*-
+ * Copyright (c) 2008 Yahoo!, Inc.
+ * All rights reserved.
+ * Written by: John Baldwin <jhb@FreeBSD.org>
+ *
+ * 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.
+ * 3. Neither the name of the author nor the names of any co-contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * 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.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/errno.h>
+#include <err.h>
+#include <fcntl.h>
+#include <libutil.h>
+#include <paths.h>
+#ifdef DEBUG
+#include <stdint.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "mptutil.h"
+
+#ifdef DEBUG
+static void	dump_config(CONFIG_PAGE_RAID_VOL_0 *vol);
+#endif
+
+#define powerof2(x)    ((((x)-1)&(x))==0)
+
+static long
+dehumanize(const char *value)
+{
+        char    *vtp;
+        long    iv;
+ 
+        if (value == NULL)
+                return (0);
+        iv = strtoq(value, &vtp, 0);
+        if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0')) {
+                return (0);
+        }
+        switch (vtp[0]) {
+        case 't': case 'T':
+                iv *= 1024;
+        case 'g': case 'G':
+                iv *= 1024;
+        case 'm': case 'M':
+                iv *= 1024;
+        case 'k': case 'K':
+                iv *= 1024;
+        case '\0':
+                break;
+        default:
+                return (0);
+        }
+        return (iv);
+}
+
+/*
+ * Lock the volume by opening its /dev device read/write.  This will
+ * only work if nothing else has it opened (including mounts).  We
+ * leak the fd on purpose since this application is not long-running.
+ */
+int
+mpt_lock_volume(U8 VolumeBus, U8 VolumeID)
+{
+	char path[MAXPATHLEN];
+	struct mpt_query_disk qd;
+	int error, vfd;
+
+	error = mpt_query_disk(VolumeBus, VolumeID, &qd);
+	if (error == ENOENT)
+		/*
+		 * This means there isn't a CAM device associated with
+		 * the volume, and thus it is already implicitly
+		 * locked, so just return.
+		 */
+		return (0);
+	if (error) {
+		errno = error;
+		warn("Unable to lookup volume device name");
+		return (-1);
+	}
+	snprintf(path, sizeof(path), "%s%s", _PATH_DEV, qd.devname);
+	vfd = open(path, O_RDWR);
+	if (vfd < 0) {
+		warn("Unable to lock volume %s", qd.devname);
+		return (-1);
+	}
+	return (0);
+}
+
+static int
+mpt_lock_physdisk(struct mpt_standalone_disk *disk)
+{
+	char path[MAXPATHLEN];
+	int dfd;
+
+	snprintf(path, sizeof(path), "%s%s", _PATH_DEV, disk->devname);
+	dfd = open(path, O_RDWR);
+	if (dfd < 0) {
+		warn("Unable to lock disk %s", disk->devname);
+		return (-1);
+	}
+	return (0);
+}
+
+static int
+mpt_lookup_standalone_disk(const char *name, struct mpt_standalone_disk *disks,
+    int ndisks, int *index)
+{
+	char *cp;
+	long bus, id;
+	int i;
+
+	/* Check for a raw <bus>:<id> string. */
+	bus = strtol(name, &cp, 0);
+	if (*cp == ':') {
+		id = strtol(cp + 1, &cp, 0);
+		if (*cp == '\0') {
+			if (bus < 0 || bus > 0xff || id < 0 || id > 0xff) {
+				errno = EINVAL;
+				return (-1);
+			}
+			for (i = 0; i < ndisks; i++) {
+				if (disks[i].bus == (U8)bus &&
+				    disks[i].target == (U8)id) {
+					*index = i;
+					return (0);
+				}
+			}
+			errno = ENOENT;
+			return (-1);
+		}
+	}
+
+	if (name[0] == 'd' && name[1] == 'a') {
+		for (i = 0; i < ndisks; i++) {
+			if (strcmp(name, disks[i].devname) == 0) {
+				*index = i;
+				return (0);
+			}
+		}
+		errno = ENOENT;
+		return (-1);
+	}
+
+	errno = EINVAL;
+	return (-1);
+}
+
+/*
+ * Mark a standalone disk as being a physical disk.
+ */
+static int
+mpt_create_physdisk(int fd, struct mpt_standalone_disk *disk, U8 *PhysDiskNum)
+{
+	CONFIG_PAGE_HEADER header;
+	CONFIG_PAGE_RAID_PHYS_DISK_0 *config_page;
+	U32 ActionData;
+
+	if (mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_PHYSDISK,
+	    0, 0, &header, NULL) < 0)
+		return (-1);
+	if (header.PageVersion > MPI_RAIDPHYSDISKPAGE0_PAGEVERSION) {
+		warnx("Unsupported RAID physdisk page 0 version %d",
+		    header.PageVersion);
+		errno = EOPNOTSUPP;
+		return (-1);
+	}		
+	config_page = calloc(1, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0));
+	config_page->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
+	config_page->Header.PageNumber = 0;
+	config_page->Header.PageLength = sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0) /
+	    4;
+	config_page->PhysDiskIOC = 0;	/* XXX */
+	config_page->PhysDiskBus = disk->bus;
+	config_page->PhysDiskID = disk->target;
+
+	/* XXX: Enclosure info for PhysDiskSettings? */
+	if (mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_PHYSDISK, 0, 0, 0, 0,
+	    config_page, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0), NULL,
+	    &ActionData, sizeof(ActionData), NULL, NULL, 1) < 0)
+		return (-1);
+	*PhysDiskNum = ActionData & 0xff;
+	return (0);
+}
+
+static int
+mpt_delete_physdisk(int fd, U8 PhysDiskNum)
+{
+
+	return (mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_PHYSDISK, 0, 0,
+	    PhysDiskNum, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, 0));
+}
+
+/*
+ * MPT's firmware does not have a clear command.  Instead, we
+ * implement it by deleting each array and disk by hand.
+ */
+static int
+clear_config(int ac, char **av)
+{
+	CONFIG_PAGE_IOC_2 *ioc2;
+	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
+	CONFIG_PAGE_IOC_3 *ioc3;
+	IOC_3_PHYS_DISK *disk;
+	CONFIG_PAGE_IOC_5 *ioc5;
+	IOC_5_HOT_SPARE *spare;
+	int ch, fd, i;
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	ioc2 = mpt_read_ioc_page(fd, 2, NULL);
+	if (ioc2 == NULL) {
+		warn("Failed to fetch volume list");
+		return (errno);
+	}
+
+	/* Lock all the volumes first. */
+	vol = ioc2->RaidVolume;
+	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
+		if (mpt_lock_volume(vol->VolumeBus, vol->VolumeID) < 0) {
+			warnx("Volume %s is busy and cannot be deleted",
+			    mpt_volume_name(vol->VolumeBus, vol->VolumeID));
+			return (EBUSY);
+		}
+	}
+
+	printf(
+	    "Are you sure you wish to clear the configuration on mpt%u? [y/N] ",
+	    mpt_unit);
+	ch = getchar();
+	if (ch != 'y' && ch != 'Y') {
+		printf("\nAborting\n");
+		return (0);
+	}
+
+	/* Delete all the volumes. */
+	vol = ioc2->RaidVolume;
+	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++)
+		if (mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME,
+		    vol->VolumeBus, vol->VolumeID, 0,
+		    MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
+		    MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0,
+		    NULL, NULL, 0) < 0)
+			warn("Failed to delete volume %s",
+			    mpt_volume_name(vol->VolumeBus, vol->VolumeID));
+	free(ioc2);
+
+	/* Delete all the spares. */
+	ioc5 = mpt_read_ioc_page(fd, 5, NULL);
+	if (ioc5 == NULL)
+		warn("Failed to fetch spare list");
+	else {
+		spare = ioc5->HotSpare;
+		for (i = 0; i < ioc5->NumHotSpares; spare++, i++)
+			if (mpt_delete_physdisk(fd, spare->PhysDiskNum) < 0)
+				warn("Failed to delete physical disk %d",
+				    spare->PhysDiskNum);
+		free(ioc5);
+	}
+
+	/* Delete any RAID physdisks that may be left. */
+	ioc3 = mpt_read_ioc_page(fd, 3, NULL);
+	if (ioc3 == NULL)
+		warn("Failed to fetch drive list");
+	else {
+		disk = ioc3->PhysDisk;
+		for (i = 0; i < ioc3->NumPhysDisks; disk++, i++)
+			if (mpt_delete_physdisk(fd, disk->PhysDiskNum) < 0)
+				warn("Failed to delete physical disk %d",
+				    disk->PhysDiskNum);
+		free(ioc3);
+	}
+
+	printf("mpt%d: Configuration cleared\n", mpt_unit);
+	mpt_rescan_bus(-1, -1);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, clear, clear_config);
+
+#define	RT_RAID0	0
+#define	RT_RAID1	1
+#define	RT_RAID1E	2
+
+static struct raid_type_entry {
+	const char *name;
+	int	raid_type;
+} raid_type_table[] = {
+	{ "raid0",	RT_RAID0 },
+	{ "raid-0",	RT_RAID0 },
+	{ "raid1",	RT_RAID1 },
+	{ "raid-1",	RT_RAID1 },
+	{ "mirror",	RT_RAID1 },
+	{ "raid1e",	RT_RAID1E },
+	{ "raid-1e",	RT_RAID1E },
+	{ NULL,		0 },
+};
+
+struct config_id_state {
+	struct mpt_standalone_disk *sdisks;
+	struct mpt_drive_list *list;
+	CONFIG_PAGE_IOC_2 *ioc2;
+	U8	target_id;
+	int	nsdisks;
+};
+
+struct drive_info {
+	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
+	struct mpt_standalone_disk *sdisk;
+};
+
+struct volume_info {
+	int	drive_count;
+	struct drive_info *drives;
+};
+
+/* Parse a comma-separated list of drives for a volume. */
+static int
+parse_volume(int fd, int raid_type, struct config_id_state *state,
+    char *volume_str, struct volume_info *info)
+{
+	struct drive_info *dinfo;
+	U8 PhysDiskNum;
+	char *cp;
+	int count, error, i;
+
+	cp = volume_str;
+	for (count = 0; cp != NULL; count++) {
+		cp = strchr(cp, ',');
+		if (cp != NULL) {
+			cp++;
+			if (*cp == ',') {
+				warnx("Invalid drive list '%s'", volume_str);
+				return (EINVAL);
+			}
+		}
+	}
+
+	/* Validate the number of drives for this volume. */
+	switch (raid_type) {
+	case RT_RAID0:
+		if (count < 2) {
+			warnx("RAID0 requires at least 2 drives in each "
+			    "array");
+			return (EINVAL);
+		}
+		break;
+	case RT_RAID1:
+		if (count != 2) {
+			warnx("RAID1 requires exactly 2 drives in each "
+			    "array");
+			return (EINVAL);
+		}
+		break;
+	case RT_RAID1E:
+		if (count < 3) {
+			warnx("RAID1E requires at least 3 drives in each "
+			    "array");
+			return (EINVAL);
+		}
+		break;
+	}
+
+	/* Validate each drive. */
+	info->drives = calloc(count, sizeof(struct drive_info));
+	info->drive_count = count;
+	for (dinfo = info->drives; (cp = strsep(&volume_str, ",")) != NULL;
+	     dinfo++) {
+		/* If this drive is already a RAID phys just fetch the info. */
+		error = mpt_lookup_drive(state->list, cp, &PhysDiskNum);
+		if (error == 0) {
+			dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
+			if (dinfo->info == NULL)
+				return (errno);
+			continue;
+		}
+
+		/* See if it is a standalone disk. */
+		if (mpt_lookup_standalone_disk(cp, state->sdisks,
+		    state->nsdisks, &i) < 0) {
+			warn("Unable to lookup drive %s", cp);
+			return (errno);
+		}
+		dinfo->sdisk = &state->sdisks[i];
+
+		/* Lock the disk, we will create phys disk pages later. */
+		if (mpt_lock_physdisk(dinfo->sdisk) < 0)
+			return (errno);
+	}
+
+	return (0);
+}
+
+/*
+ * Add RAID physdisk pages for any standalone disks that a volume is
+ * going to use.
+ */
+static int
+add_drives(int fd, struct volume_info *info, int verbose)
+{
+	struct drive_info *dinfo;
+	U8 PhysDiskNum;
+	int i;
+
+	for (i = 0, dinfo = info->drives; i < info->drive_count;
+	     i++, dinfo++) {
+		if (dinfo->info == NULL) {
+			if (mpt_create_physdisk(fd, dinfo->sdisk,
+			    &PhysDiskNum) < 0) {
+				warn(
+			    "Failed to create physical disk page for %s",
+				    dinfo->sdisk->devname);
+				return (errno);
+			}
+			if (verbose)
+				printf("Added drive %s with PhysDiskNum %u\n",
+				    dinfo->sdisk->devname, PhysDiskNum);
+
+			dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
+			if (dinfo->info == NULL)
+				return (errno);
+		}
+	}
+	return (0);
+}
+
+/*
+ * Find the next free target ID assuming that 'target_id' is the last
+ * one used.  'target_id' should be 0xff for the initial test.
+ */
+static U8
+find_next_volume(struct config_id_state *state)
+{
+	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
+	int i;
+
+restart:
+	/* Assume the current one is used. */
+	state->target_id++;
+
+	/* Search drives first. */
+	for (i = 0; i < state->nsdisks; i++)
+		if (state->sdisks[i].target == state->target_id)
+			goto restart;
+	for (i = 0; i < state->list->ndrives; i++)
+		if (state->list->drives[i]->PhysDiskID == state->target_id)
+			goto restart;
+
+	/* Seach volumes second. */
+	vol = state->ioc2->RaidVolume;
+	for (i = 0; i < state->ioc2->NumActiveVolumes; vol++, i++)
+		if (vol->VolumeID == state->target_id)
+			goto restart;
+
+	return (state->target_id);
+}
+
+/* Create a volume and populate it with drives. */
+static CONFIG_PAGE_RAID_VOL_0 *
+build_volume(int fd, struct volume_info *info, int raid_type, long stripe_size,
+    struct config_id_state *state, int verbose)
+{
+	CONFIG_PAGE_HEADER header;
+	CONFIG_PAGE_RAID_VOL_0 *vol;
+	RAID_VOL0_PHYS_DISK *rdisk;
+	struct drive_info *dinfo;
+        U32 MinLBA;
+	uint64_t MaxLBA;
+	size_t page_size;
+	int i;
+
+	if (mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_VOLUME,
+	    0, 0, &header, NULL) < 0)
+		return (NULL);
+	if (header.PageVersion > MPI_RAIDVOLPAGE0_PAGEVERSION) {
+		warnx("Unsupported RAID volume page 0 version %d",
+		    header.PageVersion);
+		errno = EOPNOTSUPP;
+		return (NULL);
+	}
+	page_size = sizeof(CONFIG_PAGE_RAID_VOL_0) +
+	    sizeof(RAID_VOL0_PHYS_DISK) * (info->drive_count - 1);
+	vol = calloc(1, page_size);
+
+	/* Header */
+	vol->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
+	vol->Header.PageNumber = 0;
+	vol->Header.PageLength = page_size / 4;
+
+	/* Properties */
+	vol->VolumeID = find_next_volume(state);
+	vol->VolumeBus = 0;
+	vol->VolumeIOC = 0;	/* XXX */
+	vol->VolumeStatus.Flags = MPI_RAIDVOL0_STATUS_FLAG_ENABLED;
+	vol->VolumeStatus.State = MPI_RAIDVOL0_STATUS_STATE_OPTIMAL;
+	vol->VolumeSettings.Settings = MPI_RAIDVOL0_SETTING_USE_DEFAULTS;
+	vol->VolumeSettings.HotSparePool = MPI_RAID_HOT_SPARE_POOL_0;
+	vol->NumPhysDisks = info->drive_count;
+
+	/* Find the smallest drive. */
+	MinLBA = info->drives[0].info->MaxLBA;
+	for (i = 1; i < info->drive_count; i++)
+		if (info->drives[i].info->MaxLBA < MinLBA)
+			MinLBA = info->drives[i].info->MaxLBA;
+
+	/*
+	 * Now chop off 512MB at the end to leave room for the
+	 * metadata.  The controller might only use 64MB, but we just
+	 * chop off the max to be simple.
+	 */
+	MinLBA -= (512 * 1024 * 1024) / 512;
+
+	switch (raid_type) {
+	case RT_RAID0:
+		vol->VolumeType = MPI_RAID_VOL_TYPE_IS;
+		vol->StripeSize = stripe_size / 512;
+		MaxLBA = MinLBA * info->drive_count;
+		break;
+	case RT_RAID1:
+		vol->VolumeType = MPI_RAID_VOL_TYPE_IM;
+		MaxLBA = MinLBA * (info->drive_count / 2);
+		break;
+	case RT_RAID1E:
+		vol->VolumeType = MPI_RAID_VOL_TYPE_IME;
+		vol->StripeSize = stripe_size / 512;
+		MaxLBA = MinLBA * info->drive_count / 2;
+		break;
+	default:
+		/* Pacify gcc. */
+		abort();		
+	}
+
+	/*
+	 * If the controller doesn't support 64-bit addressing and the
+	 * new volume is larger than 2^32 blocks, warn the user and
+	 * truncate the volume.
+	 */
+	if (MaxLBA >> 32 != 0 &&
+	    !(state->ioc2->CapabilitiesFlags &
+	    MPI_IOCPAGE2_CAP_FLAGS_RAID_64_BIT_ADDRESSING)) {
+		warnx(
+	    "Controller does not support volumes > 2TB, truncating volume.");
+		MaxLBA = 0xffffffff;
+	}
+	vol->MaxLBA = MaxLBA;
+	vol->MaxLBAHigh = MaxLBA >> 32;
+
+	/* Populate drives. */
+	for (i = 0, dinfo = info->drives, rdisk = vol->PhysDisk;
+	     i < info->drive_count; i++, dinfo++, rdisk++) {
+		if (verbose)
+			printf("Adding drive %u (%u:%u) to volume %u:%u\n",
+			    dinfo->info->PhysDiskNum, dinfo->info->PhysDiskBus,
+			    dinfo->info->PhysDiskID, vol->VolumeBus,
+			    vol->VolumeID);
+		if (raid_type == RT_RAID1) {
+			if (i == 0)
+				rdisk->PhysDiskMap =
+				    MPI_RAIDVOL0_PHYSDISK_PRIMARY;
+			else
+				rdisk->PhysDiskMap =
+				    MPI_RAIDVOL0_PHYSDISK_SECONDARY;
+		} else
+			rdisk->PhysDiskMap = i;
+		rdisk->PhysDiskNum = dinfo->info->PhysDiskNum;
+	}
+
+	return (vol);
+}
+
+static int
+create_volume(int ac, char **av)
+{
+	CONFIG_PAGE_RAID_VOL_0 *vol;
+	struct config_id_state state;
+	struct volume_info *info;
+	int ch, error, fd, i, raid_type, verbose, quick;
+	long stripe_size;
+#ifdef DEBUG
+	int dump;
+#endif
+
+	if (ac < 2) {
+		warnx("create: volume type required");
+		return (EINVAL);
+	}
+	
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	/* Lookup the RAID type first. */
+	raid_type = -1;
+	for (i = 0; raid_type_table[i].name != NULL; i++)
+		if (strcasecmp(raid_type_table[i].name, av[1]) == 0) {
+			raid_type = raid_type_table[i].raid_type;
+			break;
+		}
+
+	if (raid_type == -1) {
+		warnx("Unknown or unsupported volume type %s", av[1]);
+		return (EINVAL);
+	}
+
+	/* Parse any options. */
+	optind = 2;
+#ifdef DEBUG
+	dump = 0;
+#endif
+	quick = 0;
+	verbose = 0;
+	stripe_size = 64 * 1024;
+
+	while ((ch = getopt(ac, av, "dqs:v")) != -1) {
+		switch (ch) {
+#ifdef DEBUG
+		case 'd':
+			dump = 1;
+			break;
+#endif
+		case 'q':
+			quick = 1;
+			break;
+		case 's':
+			stripe_size = dehumanize(optarg);
+			if ((stripe_size < 512) || (!powerof2(stripe_size))) {
+				warnx("Invalid stripe size %s", optarg);
+				return (EINVAL);
+			}
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case '?':
+		default:
+			return (EINVAL);
+		}
+	}
+	ac -= optind;
+	av += optind;
+
+	/* Fetch existing config data. */
+	state.ioc2 = mpt_read_ioc_page(fd, 2, NULL);
+	if (state.ioc2 == NULL) {
+		warn("Failed to read volume list");
+		return (errno);
+	}
+	state.list = mpt_pd_list(fd);
+	if (state.list == NULL)
+		return (errno);
+	error = mpt_fetch_disks(fd, &state.nsdisks, &state.sdisks);
+	if (error) {
+		warn("Failed to fetch standalone disk list");
+		return (error);
+	}	
+	state.target_id = 0xff;
+	
+	/* Parse the drive list. */
+	if (ac != 1) {
+		warnx("Exactly one drive list is required");
+		return (EINVAL);
+	}
+	info = calloc(1, sizeof(*info));
+	error = parse_volume(fd, raid_type, &state, av[0], info);
+	if (error)
+		return (error);
+
+	/* Create RAID physdisk pages for standalone disks. */
+	error = add_drives(fd, info, verbose);
+	if (error)
+		return (error);
+
+	/* Build the volume. */
+	vol = build_volume(fd, info, raid_type, stripe_size, &state, verbose);
+
+#ifdef DEBUG
+	if (dump) {
+		dump_config(vol);
+		goto skip;
+	}
+#endif
+
+	/* Send the new volume to the controller. */
+	if (mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_VOLUME, vol->VolumeBus,
+	    vol->VolumeID, 0, quick ? MPI_RAID_ACTION_ADATA_DO_NOT_SYNC : 0,
+	    vol, vol->Header.PageLength * 4, NULL, NULL, 0, NULL, NULL, 1) <
+	    0) {
+		warn("Failed to add volume");
+		return (errno);
+	}
+
+#ifdef DEBUG
+skip:
+#endif
+	mpt_rescan_bus(vol->VolumeBus, vol->VolumeID);
+
+	/* Clean up. */
+	free(vol);
+	free(info);
+	free(state.sdisks);
+	mpt_free_pd_list(state.list);
+	free(state.ioc2);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, create, create_volume);
+
+static int
+delete_volume(int ac, char **av)
+{
+	U8 VolumeBus, VolumeID;
+	int fd;
+
+	if (ac != 2) {
+		warnx("delete: volume required");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	if (mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID) < 0) {
+		warn("Invalid volume %s", av[1]);
+		return (errno);
+	}
+
+	if (mpt_lock_volume(VolumeBus, VolumeID) < 0)
+		return (errno);
+
+	if (mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME, VolumeBus,
+	    VolumeID, 0, MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
+	    MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0, NULL,
+	    NULL, 0) < 0) {
+		warn("Failed to delete volume");
+		return (errno);
+	}
+
+	mpt_rescan_bus(-1, -1);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, delete, delete_volume);
+
+static int
+find_volume_spare_pool(int fd, const char *name, int *pool)
+{
+	CONFIG_PAGE_RAID_VOL_0 *info;
+	CONFIG_PAGE_IOC_2 *ioc2;
+	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
+	U8 VolumeBus, VolumeID;
+	int i, j, new_pool, pool_count[7];
+
+	if (mpt_lookup_volume(fd, name, &VolumeBus, &VolumeID) < 0) {
+		warn("Invalid volume %s", name);
+		return (-1);
+	}
+
+	info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
+	if (info == NULL)
+		return (-1);
+
+	/*
+	 * Check for an existing pool other than pool 0 (used for
+	 * global spares).
+	 */
+	if ((info->VolumeSettings.HotSparePool & ~MPI_RAID_HOT_SPARE_POOL_0) !=
+	    0) {
+		*pool = 1 << (ffs(info->VolumeSettings.HotSparePool &
+		    ~MPI_RAID_HOT_SPARE_POOL_0) - 1);
+		return (0);
+	}
+	free(info);
+
+	/*
+	 * Try to find a free pool.  First, figure out which pools are
+	 * in use.
+	 */
+	ioc2 = mpt_read_ioc_page(fd, 2, NULL);
+	if (ioc2 == NULL) {
+		warn("Failed to fetch volume list");
+		return (-1);
+	}
+	bzero(pool_count, sizeof(pool_count));	
+	vol = ioc2->RaidVolume;
+	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
+		info = mpt_vol_info(fd, vol->VolumeBus, vol->VolumeID, NULL);
+		if (info == NULL)
+			return (-1);
+		for (j = 0; j < 7; j++)
+			if (info->VolumeSettings.HotSparePool & (1 << (j + 1)))
+				pool_count[j]++;
+		free(info);
+	}
+	free(ioc2);
+
+	/* Find the pool with the lowest use count. */
+	new_pool = 0;
+	for (i = 1; i < 7; i++)
+		if (pool_count[i] < pool_count[new_pool])
+			new_pool = i;
+	new_pool++;
+
+	/* Add this pool to the volume. */
+	info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
+	if (info == NULL)
+		return (-1);
+	info->VolumeSettings.HotSparePool |= (1 << new_pool);
+	if (mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_VOLUME_SETTINGS,
+	    VolumeBus, VolumeID, 0, *(U32 *)&info->VolumeSettings, NULL, 0,
+	    NULL, NULL, 0, NULL, NULL, 0) < 0) {
+		warnx("Failed to add spare pool %d to %s", new_pool,
+		    mpt_volume_name(VolumeBus, VolumeID));
+		return (-1);
+	}
+	free(info);
+
+	*pool = (1 << new_pool);
+	return (0);
+}
+
+static int
+add_spare(int ac, char **av)
+{
+	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
+	struct mpt_standalone_disk *sdisks;
+	struct mpt_drive_list *list;
+	U8 PhysDiskNum;
+	int error, fd, i, nsdisks, pool;
+
+	if (ac < 2) {
+		warnx("add spare: drive required");
+		return (EINVAL);
+	}
+	if (ac > 3) {
+		warnx("add spare: extra arguments");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	if (ac == 3) {
+		if (find_volume_spare_pool(fd, av[2], &pool) < 0)
+			return (errno);
+	} else
+		pool = MPI_RAID_HOT_SPARE_POOL_0;
+
+	list = mpt_pd_list(fd);
+	if (list == NULL)
+		return (errno);
+
+	error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
+	if (error) {
+		error = mpt_fetch_disks(fd, &nsdisks, &sdisks);
+		if (error != 0) {
+			warn("Failed to fetch standalone disk list");
+			return (error);
+		}
+
+		if (mpt_lookup_standalone_disk(av[1], sdisks, nsdisks, &i) <
+		    0) {
+			warn("Unable to lookup drive %s", av[1]);
+			return (errno);
+		}
+
+		if (mpt_lock_physdisk(&sdisks[i]) < 0)
+			return (errno);
+
+		if (mpt_create_physdisk(fd, &sdisks[i], &PhysDiskNum) < 0) {
+			warn("Failed to create physical disk page");
+			return (errno);
+		}
+		free(sdisks);
+	}
+	mpt_free_pd_list(list);
+
+	info = mpt_pd_info(fd, PhysDiskNum, NULL);
+	if (info == NULL) {
+		warn("Failed to fetch drive info");
+		return (errno);
+	}
+
+	info->PhysDiskSettings.HotSparePool = pool;
+	error = mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_PHYSDISK_SETTINGS, 0,
+	    0, PhysDiskNum, *(U32 *)&info->PhysDiskSettings, NULL, 0, NULL,
+	    NULL, 0, NULL, NULL, 0);
+	if (error) {
+		warn("Failed to assign spare");
+		return (errno);
+	}
+
+	free(info);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, add, add_spare);
+
+static int
+remove_spare(int ac, char **av)
+{
+	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
+	struct mpt_drive_list *list;
+	U8 PhysDiskNum;
+	int error, fd;
+
+	if (ac != 2) {
+		warnx("remove spare: drive required");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	list = mpt_pd_list(fd);
+	if (list == NULL)
+		return (errno);
+
+	error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
+	if (error) {
+		warn("Failed to find drive %s", av[1]);
+		return (error);
+	}
+	mpt_free_pd_list(list);
+
+	
+	info = mpt_pd_info(fd, PhysDiskNum, NULL);
+	if (info == NULL) {
+		warn("Failed to fetch drive info");
+		return (errno);
+	}
+
+	if (info->PhysDiskSettings.HotSparePool == 0) {
+		warnx("Drive %u is not a hot spare", PhysDiskNum);
+		return (EINVAL);
+	}
+
+	if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
+		warn("Failed to delete physical disk page");
+		return (errno);
+	}
+
+	mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
+	free(info);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, remove, remove_spare);
+
+#ifdef DEBUG
+MPT_TABLE(top, pd);
+
+static int
+pd_create(int ac, char **av)
+{
+	struct mpt_standalone_disk *disks;
+	int error, fd, i, ndisks;
+	U8 PhysDiskNum;
+
+	if (ac != 2) {
+		warnx("pd create: drive required");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	error = mpt_fetch_disks(fd, &ndisks, &disks);
+	if (error != 0) {
+		warn("Failed to fetch standalone disk list");
+		return (error);
+	}
+
+	if (mpt_lookup_standalone_disk(av[1], disks, ndisks, &i) < 0) {
+		warn("Unable to lookup drive");
+		return (errno);
+	}
+
+	if (mpt_lock_physdisk(&disks[i]) < 0)
+		return (errno);
+
+	if (mpt_create_physdisk(fd, &disks[i], &PhysDiskNum) < 0) {
+		warn("Failed to create physical disk page");
+		return (errno);
+	}
+	free(disks);
+
+	printf("Added drive %s with PhysDiskNum %u\n", av[1], PhysDiskNum);
+
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(pd, create, pd_create);
+
+static int
+pd_delete(int ac, char **av)
+{
+	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
+	struct mpt_drive_list *list;
+	int fd;
+	U8 PhysDiskNum;
+
+	if (ac != 2) {
+		warnx("pd delete: drive required");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	list = mpt_pd_list(fd);
+	if (list == NULL)
+		return (errno);
+
+	if (mpt_lookup_drive(list, av[1], &PhysDiskNum) < 0) {
+		warn("Failed to find drive %s", av[1]);
+		return (errno);
+	}
+	mpt_free_pd_list(list);
+
+	info = mpt_pd_info(fd, PhysDiskNum, NULL);
+	if (info == NULL) {
+		warn("Failed to fetch drive info");
+		return (errno);
+	}
+
+	if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
+		warn("Failed to delete physical disk page");
+		return (errno);
+	}
+
+	mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
+	free(info);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(pd, delete, pd_delete);
+
+/* Display raw data about a volume config. */
+static void
+dump_config(CONFIG_PAGE_RAID_VOL_0 *vol)
+{
+	int i;
+
+	printf("Volume Configuration (Debug):\n");
+	printf(
+   " Page Header: Type 0x%02x Number 0x%02x Length 0x%02x(%u) Version 0x%02x\n",
+	    vol->Header.PageType, vol->Header.PageNumber,
+	    vol->Header.PageLength, vol->Header.PageLength * 4,
+	    vol->Header.PageVersion);
+	printf("     Address: %d:%d IOC %d\n", vol->VolumeBus, vol->VolumeID,
+	    vol->VolumeIOC);
+	printf("        Type: %d (%s)\n", vol->VolumeType,
+	    mpt_raid_level(vol->VolumeType));
+	printf("      Status: %s (Flags 0x%02x)\n",
+	    mpt_volstate(vol->VolumeStatus.State), vol->VolumeStatus.Flags);
+	printf("    Settings: 0x%04x (Spare Pools 0x%02x)\n",
+	    vol->VolumeSettings.Settings, vol->VolumeSettings.HotSparePool);
+	printf("      MaxLBA: %ju\n", (uintmax_t)vol->MaxLBAHigh << 32 |
+	    vol->MaxLBA);
+	printf(" Stripe Size: %ld\n", (long)vol->StripeSize * 512);
+	printf(" %d Disks:\n", vol->NumPhysDisks);
+
+	for (i = 0; i < vol->NumPhysDisks; i++)
+		printf("    Disk %d: Num 0x%02x Map 0x%02x\n", i,
+		    vol->PhysDisk[i].PhysDiskNum, vol->PhysDisk[i].PhysDiskMap);
+}
+
+static int
+debug_config(int ac, char **av)
+{
+	CONFIG_PAGE_RAID_VOL_0 *vol;
+	U8 VolumeBus, VolumeID;
+	int fd;
+
+	if (ac != 2) {
+		warnx("debug: volume required");
+		return (EINVAL);
+	}
+
+	fd = mpt_open(mpt_unit);
+	if (fd < 0) {
+		warn("mpt_open");
+		return (errno);
+	}
+
+	if (mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID) < 0) {
+		warn("Invalid volume: %s", av[1]);
+		return (errno);
+	}
+
+	vol = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
+	if (vol == NULL) {
+		warn("Failed to get volume info");
+		return (errno);
+	}
+
+	dump_config(vol);
+	free(vol);
+	close(fd);
+
+	return (0);
+}
+MPT_COMMAND(top, debug, debug_config);
+#endif