xref: /src/sbin/bioctl/bioctl.c

/* $NetBSD: bioctl.c,v 1.1.2.3 2008/08/29 21:24:18 bouyer Exp $ */
/* $OpenBSD: bioctl.c,v 1.52 2007/03/20 15:26:06 jmc Exp $ */

/*
 * Copyright (c) 2007, 2008 Juan Romero Pardines
 * Copyright (c) 2004, 2005 Marco Peereboom
 * 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 AUTHORS 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 AUTHORS 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>

#ifndef lint
__RCSID("$NetBSD: bioctl.c,v 1.1.2.3 2008/08/29 21:24:18 bouyer Exp $");
#endif

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <dev/biovar.h>

#include <errno.h>
#include <err.h>
#include <fcntl.h>
#include <util.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <util.h>
#include "strtonum.h"

struct command {
	const char *cmd_name;
	const char *arg_names;
	void (*cmd_func)(int, int, char **);
};

struct biotmp {
	struct bioc_inq *bi;
	struct bioc_vol *bv;
	char volname[64];
	int fd;
	int volid;
	int diskid;
	bool format;
	bool show_disknovol;
};

struct locator {
	int channel;
	int target;
	int lun;
};

int   dehumanize_number(const char *, int64_t *);


static void 	usage(void);
static void	bio_alarm(int, int, char **);
static void	bio_show_common(int, int, char **);
static int	bio_show_volumes(struct biotmp *);
static void	bio_show_disks(struct biotmp *);
static void	bio_setblink(int, int, char **);
static void 	bio_blink(int, char *, int, int);
static void	bio_setstate_hotspare(int, int, char **);
static void	bio_setstate_passthru(int, int, char **);
static void	bio_setstate_common(int, char *, struct bioc_setstate *,
				    struct locator *);
static void	bio_setstate_consistency(int, int, char **);
static void	bio_volops_create(int, int, char **);
#ifdef notyet
static void	bio_volops_modify(int, int, char **);
#endif
static void	bio_volops_remove(int, int, char **);

static const char *str2locator(const char *, struct locator *);

static struct bio_locate bl;
static struct command commands[] = {
	{
	  "show",
	  "[disks] | [volumes]",
	  bio_show_common },
	{
	  "alarm",
	  "[enable] | [disable] | [silence] | [test]",
	  bio_alarm },
	{
	  "blink",
	  "start [channel:target[.lun]] | stop [channel:target[.lun]]",
	  bio_setblink },
	{
	  "hotspare",
	  "add channel:target.lun | remove channel:target.lun",
	  bio_setstate_hotspare },
	{
	  "passthru",
	  "add DISKID channel:target.lun | remove channel:target.lun",
	  bio_setstate_passthru },
	{
	  "check",
	  "start VOLID | stop VOLID",
	  bio_setstate_consistency },
	{
	  "create",
	  "volume VOLID DISKIDs [SIZE] STRIPE RAID_LEVEL channel:target.lun",
	  bio_volops_create },
#ifdef notyet
	{
	  "modify",
	  "volume VOLID STRIPE RAID_LEVEL channel:target.lun",
	  bio_volops_modify },
#endif
	{
	  "remove",
	  "volume VOLID channel:target.lun",
	  bio_volops_remove },

	{ NULL, NULL, NULL }
};

int
main(int argc, char **argv)
{
	char 		*dvname;
	const char 	*cmdname;
	int 		fd = 0, i;

	/* Must have at least: device command */
	if (argc < 3)
		usage();

	/* Skip program name, get and skip device name and command */
	setprogname(*argv);
	dvname = argv[1];
	cmdname = argv[2];
	argv += 3;
	argc -= 3;

	/* Look up and call the command */
	for (i = 0; commands[i].cmd_name != NULL; i++)
		if (strcmp(cmdname, commands[i].cmd_name) == 0)
			break;
	if (commands[i].cmd_name == NULL)
		errx(EXIT_FAILURE, "unknown command: %s", cmdname);

	/* Locate the device by issuing the BIOCLOCATE ioctl */
	fd = open("/dev/bio", O_RDWR);
	if (fd == -1)
		err(EXIT_FAILURE, "Can't open /dev/bio");

	bl.bl_name = dvname;
	if (ioctl(fd, BIOCLOCATE, &bl) == -1)
		errx(EXIT_FAILURE, "Can't locate %s device via /dev/bio",
		    bl.bl_name);

	/* and execute the command */
	(*commands[i].cmd_func)(fd, argc, argv);

	(void)close(fd);
	exit(EXIT_SUCCESS);
}

static void
usage(void)
{
	int i;

	(void)fprintf(stderr, "usage: %s device command [arg [...]]\n",
	    getprogname());

	(void)fprintf(stderr, "Available commands:\n");
	for (i = 0; commands[i].cmd_name != NULL; i++)
		(void)fprintf(stderr, "  %s %s\n", commands[i].cmd_name,
		    commands[i].arg_names);

	exit(EXIT_FAILURE);
	/* NOTREACHED */
}

static const char *
str2locator(const char *string, struct locator *location)
{
	const char 	*errstr;
	char 		parse[80], *targ, *lun;

	strlcpy(parse, string, sizeof parse);
	targ = strchr(parse, ':');
	if (targ == NULL)
		return "target not specified";

	*targ++ = '\0';
	lun = strchr(targ, '.');
	if (lun != NULL) {
		*lun++ = '\0';
		location->lun = strtonum(lun, 0, 256, &errstr);
		if (errstr)
			return errstr;
	} else
		location->lun = 0;

	location->target = strtonum(targ, 0, 256, &errstr);
	if (errstr)
		return errstr;
	location->channel = strtonum(parse, 0, 256, &errstr);
	if (errstr)
		return errstr;
	return NULL;
}

/*
 * Shows info about available RAID volumes.
 */
static int
bio_show_volumes(struct biotmp *bt)
{
	struct bioc_vol 	bv;
	const char 		*status, *rtypestr, *stripestr;
	char 			size[64], percent[16], seconds[20];
	char 			rtype[16], stripe[16], tmp[32];

	rtypestr = stripestr = NULL;

	memset(&bv, 0, sizeof(bv));
	bv.bv_cookie = bl.bl_cookie;
	bv.bv_volid = bt->volid;
	bv.bv_percent = -1;
	bv.bv_seconds = -1;

	if (ioctl(bt->fd, BIOCVOL, &bv) == -1)
		err(EXIT_FAILURE, "BIOCVOL");

	percent[0] = '\0';
	seconds[0] = '\0';
	if (bv.bv_percent != -1)
		snprintf(percent, sizeof(percent),
		    " %3.2f%% done", bv.bv_percent / 10.0);
	if (bv.bv_seconds)
		snprintf(seconds, sizeof(seconds),
		    " %u seconds", bv.bv_seconds);

	switch (bv.bv_status) {
	case BIOC_SVONLINE:
		status = BIOC_SVONLINE_S;
		break;
	case BIOC_SVOFFLINE:
		status = BIOC_SVOFFLINE_S;
		break;
	case BIOC_SVDEGRADED:
		status = BIOC_SVDEGRADED_S;
		break;
	case BIOC_SVBUILDING:
		status = BIOC_SVBUILDING_S;
		break;
	case BIOC_SVREBUILD:
		status = BIOC_SVREBUILD_S;
		break;
	case BIOC_SVMIGRATING:
		status = BIOC_SVMIGRATING_S;
		break;
	case BIOC_SVSCRUB:
		status = BIOC_SVSCRUB_S;
		break;
	case BIOC_SVCHECKING:
		status = BIOC_SVCHECKING_S;
		break;
	case BIOC_SVINVALID:
	default:
		status = BIOC_SVINVALID_S;
		break;
	}

	snprintf(bt->volname, sizeof(bt->volname), "%u", bv.bv_volid);
	if (bv.bv_vendor)
		snprintf(tmp, sizeof(tmp), "%s %s", bv.bv_dev, bv.bv_vendor);
	else
		snprintf(tmp, sizeof(tmp), "%s", bv.bv_dev);

	switch (bv.bv_level) {
	case BIOC_SVOL_HOTSPARE:
		rtypestr = "Hot spare";
		stripestr = "N/A";
		break;
	case BIOC_SVOL_PASSTHRU:
		rtypestr = "Pass through";
		stripestr = "N/A";
		break;
	case BIOC_SVOL_RAID01:
		rtypestr = "RAID 0+1";
		break;
	case BIOC_SVOL_RAID10:
		rtypestr = "RAID 1+0";
		break;
	default:
		snprintf(rtype, sizeof(rtype), "RAID %u", bv.bv_level);
		if (bv.bv_level == 1 || bv.bv_stripe_size == 0)
			stripestr = "N/A";
		break;
	}

	if (rtypestr)
		snprintf(rtype, sizeof(rtype), rtypestr);
	if (stripestr)
		snprintf(stripe, sizeof(stripe), stripestr);
	else
		snprintf(stripe, sizeof(stripe), "%uK", bv.bv_stripe_size);

	humanize_number(size, 5, (int64_t)bv.bv_size, "", HN_AUTOSCALE,
	    HN_B | HN_NOSPACE | HN_DECIMAL);

	printf("%6s %-12s %4s %20s %8s %6s %s%s\n",
	    bt->volname, status, size, tmp,
	    rtype, stripe, percent, seconds);

	bt->bv = &bv;

	return bv.bv_nodisk;
}

/*
 * Shows info about physical disks.
 */
static void
bio_show_disks(struct biotmp *bt)
{
	struct bioc_disk 	bd;
	const char 		*status;
	char 			size[64], serial[32], scsiname[16];

	memset(&bd, 0, sizeof(bd));
	bd.bd_cookie = bl.bl_cookie;
	bd.bd_diskid = bt->diskid;
	bd.bd_volid = bt->volid;

	if (bt->show_disknovol) {
		if (ioctl(bt->fd, BIOCDISK_NOVOL, &bd) == -1)
			err(EXIT_FAILURE, "BIOCDISK_NOVOL");
		if (!bd.bd_disknovol)
			return;
	} else {
		if (ioctl(bt->fd, BIOCDISK, &bd) == -1)
			err(EXIT_FAILURE, "BIOCDISK");
	}

	switch (bd.bd_status) {
	case BIOC_SDONLINE:
		status = BIOC_SDONLINE_S;
		break;
	case BIOC_SDOFFLINE:
		status = BIOC_SDOFFLINE_S;
		break;
	case BIOC_SDFAILED:
		status = BIOC_SDFAILED_S;
		break;
	case BIOC_SDREBUILD:
		status = BIOC_SDREBUILD_S;
		break;
	case BIOC_SDHOTSPARE:
		status = BIOC_SDHOTSPARE_S;
		break;
	case BIOC_SDUNUSED:
		status = BIOC_SDUNUSED_S;
		break;
	case BIOC_SDSCRUB:
		status = BIOC_SDSCRUB_S;
		break;
	case BIOC_SDPASSTHRU:
		status = BIOC_SDPASSTHRU_S;
		break;
	case BIOC_SDINVALID:
	default:
		status = BIOC_SDINVALID_S;
		break;
	}

	if (bt->format)
		snprintf(bt->volname, sizeof(bt->volname),
		    "%u:%u", bt->bv->bv_volid, bd.bd_diskid);

	humanize_number(size, 5, bd.bd_size, "", HN_AUTOSCALE,
	    HN_B | HN_NOSPACE | HN_DECIMAL);

	if (bd.bd_procdev[0])
		snprintf(scsiname, sizeof(scsiname), "%u:%u.%u %s",
	    	    bd.bd_channel, bd.bd_target, bd.bd_lun,
		    bd.bd_procdev);
	else
		snprintf(scsiname, sizeof(scsiname), "%u:%u.%u noencl",
		    bd.bd_channel, bd.bd_target, bd.bd_lun);

	if (bd.bd_serial[0])
		strlcpy(serial, bd.bd_serial, sizeof(serial));
	else
		strlcpy(serial, "unknown serial", sizeof(serial));

	if (bt->format)
		printf("%6s %-12s %4s %20s <%s>\n",
		    bt->volname, status, size, scsiname,
				    bd.bd_vendor);
	else
		printf("%5d [%-28s] %-12s %-6s %12s\n",
		    bt->diskid, bd.bd_vendor, status, size, scsiname);

}

/*
 * Shows info about volumes/disks.
 */
static void
bio_show_common(int fd, int argc, char **argv)
{
	struct biotmp 		*biot;
	struct bioc_inq 	bi;
	int 			i, d, ndisks;
	bool 			show_all, show_disks;
	bool 			show_vols, show_caps;

	show_all = show_disks = show_vols = show_caps = false;

	if (argc > 1)
		usage();

	if (argv[0]) {
		if (strcmp(argv[0], "disks") == 0)
			show_disks = true;
		else if (strcmp(argv[0], "volumes") == 0)
			show_vols = true;
		else
			usage();
	} else
		show_all = true;

	memset(&bi, 0, sizeof(bi));
	bi.bi_cookie = bl.bl_cookie;

	if (ioctl(fd, BIOCINQ, &bi) == -1)
		err(EXIT_FAILURE, "BIOCINQ");

	/*
	 * If there are volumes there's no point to continue.
	 */
	if (show_all || show_vols) {
		if (!bi.bi_novol) {
			warnx("no volumes available");
			return;
		}
	}

	biot = calloc(1, sizeof(*biot));
	if (!biot)
		err(EXIT_FAILURE, "biotemp calloc");

	biot->fd = fd;
	biot->bi = &bi;
	/*
	 * Go to the disks section if that was specified.
	 */
	if (show_disks)
		goto disks;

	/*
	 * Common code to show only info about volumes and disks
	 * associated to them.
	 */
	printf("%6s %-12s %4s %20s %8s %6s\n",
	    "Volume", "Status", "Size", "Device/Label",
	    "Level", "Stripe");
	printf("=============================================="
	       "===============\n");

	for (i = 0; i < bi.bi_novol; i++) {
		biot->format = true;
		biot->volid = i;
		ndisks = bio_show_volumes(biot);
		if (show_vols)
			continue;

		for (d = 0; d < ndisks; d++) {
			biot->diskid = d;
			bio_show_disks(biot);
		}

	}
	goto out;

disks:
	/*
	 * show info about all disks connected to the raid controller,
	 * even if they aren't associated with a volume or raid set.
	 */
	if (show_disks) {
		printf("%5s %-30s %-12s %-6s %12s\n",
		    "Disk", "Model/Serial", "Status", "Size", "Location");
		printf("==============================================="
		       "======================\n");
		for (d = 0; d < bi.bi_nodisk; d++) {
			biot->show_disknovol = true;
			biot->diskid = d;
			bio_show_disks(biot);
		}
	}
out:
	free(biot);
}

/*
 * To handle the alarm feature.
 */
static void
bio_alarm(int fd, int argc, char **argv)
{
	struct bioc_alarm 	ba;
	bool 			show = false;

	memset(&ba, 0, sizeof(ba));
	ba.ba_cookie = bl.bl_cookie;

	if (argc > 1)
		usage();

	if (argc == 0) {
		/* show alarm status */
		ba.ba_opcode = BIOC_GASTATUS;
		show = true;
	} else if (strcmp(argv[0], "silence") == 0) {
		/* silence alarm */
		ba.ba_opcode = BIOC_SASILENCE;
	} else if (strcmp(argv[0], "enable") == 0) {
		/* enable alarm */
		ba.ba_opcode = BIOC_SAENABLE;
	} else if (strcmp(argv[0], "disable") == 0) {
		/* disable alarm */
		ba.ba_opcode = BIOC_SADISABLE;
	} else if (strcmp(argv[0], "test") == 0) {
		/* test alarm */
		ba.ba_opcode = BIOC_SATEST;
	} else
		usage();

	if (ioctl(fd, BIOCALARM, &ba) == -1)
		err(EXIT_FAILURE, "BIOCALARM");

	if (show)
		printf("alarm is currently %s\n",
		    ba.ba_status ? "enabled" : "disabled");
}

/*
 * To add/remove a hotspare disk.
 */
static void
bio_setstate_hotspare(int fd, int argc, char **argv)
{
	struct bioc_setstate	bs;
	struct locator		location;

	memset(&bs, 0, sizeof(bs));

	if (argc != 2)
		usage();

	if (strcmp(argv[0], "add") == 0)
		bs.bs_status = BIOC_SSHOTSPARE;
	else if (strcmp(argv[0], "remove") == 0)
		bs.bs_status = BIOC_SSDELHOTSPARE;
	else
		usage();

	bio_setstate_common(fd, argv[1], &bs, &location);
}

/*
 * To add/remove a pass through disk.
 */
static void
bio_setstate_passthru(int fd, int argc, char **argv)
{
	struct bioc_setstate	bs;
	struct locator		location;
	char			*endptr;
	bool			rem = false;

	if (argc > 3)
		usage();

	memset(&bs, 0, sizeof(bs));

	if (strcmp(argv[0], "add") == 0) {
		if (argv[1] == NULL || argv[2] == NULL)
			usage();

		bs.bs_status = BIOC_SSPASSTHRU;
	} else if (strcmp(argv[0], "remove") == 0) {
		if (argv[1] == NULL)
			usage();

		bs.bs_status = BIOC_SSDELPASSTHRU;
		rem = true;
	} else
		usage();

	if (rem)
		bio_setstate_common(fd, argv[1], &bs, &location);
	else {
		bs.bs_other_id = (unsigned int)strtoul(argv[1], &endptr, 10);
		if (*endptr != '\0')
			errx(EXIT_FAILURE, "Invalid Volume ID value");

		bio_setstate_common(fd, argv[2], &bs, &location);
	}
}

/*
 * To start/stop a consistency check in a RAID volume.
 */
static void
bio_setstate_consistency(int fd, int argc, char **argv)
{
	struct bioc_setstate	bs;
	char			*endptr;

	if (argc > 2)
		usage();

	memset(&bs, 0, sizeof(bs));

	if (strcmp(argv[0], "start") == 0)
		bs.bs_status = BIOC_SSCHECKSTART_VOL;
	else if (strcmp(argv[0], "stop") == 0)
		bs.bs_status = BIOC_SSCHECKSTOP_VOL;
	else
		usage();

	bs.bs_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
	if (*endptr != '\0')
		errx(EXIT_FAILURE, "Invalid Volume ID value");

	bio_setstate_common(fd, NULL, &bs, NULL);
}

static void
bio_setstate_common(int fd, char *arg, struct bioc_setstate *bs,
		    struct locator *location)
{
	const char		*errstr;

	if (!arg || !location)
		goto send;

	errstr = str2locator(arg, location);
	if (errstr)
		errx(EXIT_FAILURE, "Target %s: %s", arg, errstr);

	bs->bs_channel = location->channel;
	bs->bs_target = location->target;
	bs->bs_lun = location->lun;

send:
	bs->bs_cookie = bl.bl_cookie;

	if (ioctl(fd, BIOCSETSTATE, bs) == -1)
		err(EXIT_FAILURE, "BIOCSETSTATE");
}

/*
 * To create a RAID volume.
 */
static void
bio_volops_create(int fd, int argc, char **argv)
{
	struct bioc_volops	bc;
	struct bioc_inq 	bi;
	struct bioc_disk	bd;
	struct locator		location;
	uint64_t 		total_size = 0, disksize = 0;
	int64_t 		volsize = 0;
	const char 		*errstr;
	char 			*endptr, *stripe, levelstr[32];
	char			*scsiname, *raid_level, size[64];
	int			disk_first = 0, disk_end = 0;
	int			i, nfreedisks = 0;
	int			user_disks = 0;

	if (argc < 6 || argc > 7)
		usage();

	if (strcmp(argv[0], "volume") != 0)
		usage();

	/*
	 * No size requested, use max size depending on RAID level.
	 */
	if (argc == 6) {
		stripe = argv[3];
		raid_level = argv[4];
		scsiname = argv[5];
	} else {
		stripe = argv[4];
		raid_level = argv[5];
		scsiname = argv[6];
	}

	memset(&bd, 0, sizeof(bd));
	memset(&bc, 0, sizeof(bc));
	memset(&bi, 0, sizeof(bi));

	bc.bc_cookie = bd.bd_cookie = bi.bi_cookie = bl.bl_cookie;
	bc.bc_opcode = BIOC_VCREATE_VOLUME;

	bc.bc_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
	if (*endptr != '\0')
		errx(EXIT_FAILURE, "Invalid Volume ID value");

	if (argc == 7)
		if (dehumanize_number(argv[3], &volsize) == -1)
			errx(EXIT_FAILURE, "Invalid SIZE value");

	bc.bc_stripe = (unsigned int)strtoul(stripe, &endptr, 10);
	if (*endptr != '\0')
		errx(EXIT_FAILURE, "Invalid STRIPE size value");

	bc.bc_level = (unsigned int)strtoul(raid_level, &endptr, 10);
	if (*endptr != '\0')
		errx(EXIT_FAILURE, "Invalid RAID_LEVEL value");

	errstr = str2locator(scsiname, &location);
	if (errstr)
		errx(EXIT_FAILURE, "Target %s: %s", scsiname, errstr);

	/*
	 * Parse the device list that will be used for the volume,
	 * by using a bit field for the disks.
	 */
	if ((isdigit((unsigned char)argv[2][0]) == 0) || argv[2][1] != '-' ||
	    (isdigit((unsigned char)argv[2][2]) == 0))
		errx(EXIT_FAILURE, "Invalid DISKIDs value");

	disk_first = atoi(&argv[2][0]);
	disk_end = atoi(&argv[2][2]);

	for (i = disk_first; i < disk_end + 1; i++) {
		bc.bc_devmask |= (1 << i);
		user_disks++;
	}

	/*
	 * Find out how many disks are free and how much size we
	 * have available for the new volume.
	 */
	if (ioctl(fd, BIOCINQ, &bi) == -1)
		err(EXIT_FAILURE, "BIOCINQ");

	for (i = 0; i < bi.bi_nodisk; i++) {
		bd.bd_diskid = i;
		if (ioctl(fd, BIOCDISK_NOVOL, &bd) == -1)
			err(EXIT_FAILURE, "BIOCDISK_NOVOL");

		if (bd.bd_status == BIOC_SDUNUSED) {
			if (i == 0)
				disksize = bd.bd_size;

			total_size += bd.bd_size;
			nfreedisks++;
		}
	}

	if (user_disks > nfreedisks)
		errx(EXIT_FAILURE, "specified disks number is higher than "
		    "available free disks");

	/*
	 * Basic checks to be sure we don't do something stupid.
	 */
	if (nfreedisks == 0)
		errx(EXIT_FAILURE, "No free disks available");

	switch (bc.bc_level) {
	case 0:	/* RAID 0 requires at least one disk */
		if (argc == 7) {
			if (volsize > (disksize * user_disks))
				errx(EXIT_FAILURE, "volume size specified "
				   "is larger than available on free disks");
			bc.bc_size = (uint64_t)volsize;
		} else
			bc.bc_size = disksize * user_disks;

		break;
	case 1:	/* RAID 1 requires two disks and size is total / 2 */
		if (nfreedisks < 2 || user_disks < 2)
			errx(EXIT_FAILURE, "2 disks are required at least for "
			    "this RAID level");

		/* RAID 1+0 requires three disks at least */
		if (nfreedisks > 2 && user_disks > 2)
			bc.bc_level = BIOC_SVOL_RAID10;

		if (argc == 7) {
			if (volsize > ((disksize * user_disks) / 2))
				errx(EXIT_FAILURE, "volume size specified "
				   "is larger than available on free disks");
			bc.bc_size = (uint64_t)volsize;
		} else
			bc.bc_size = ((disksize * user_disks) / 2);

		break;
	case 3:	/* RAID 3/5 requires three disks and size is total - 1 disk */
	case 5:
		if (nfreedisks < 3 || user_disks < 3)
			errx(EXIT_FAILURE, "3 disks are required at least for "
			    "this RAID level");

		if (argc == 7) {
			if (volsize > (disksize * (user_disks - 1)))
				errx(EXIT_FAILURE, "volume size specified "
				    "is larger than available on free disks");
			bc.bc_size = (uint64_t)volsize;
		} else
			bc.bc_size = (disksize * (user_disks - 1));

		break;
	case 6:	/* RAID 6 requires four disks and size is total - 2 disks */
		if (nfreedisks < 4 || user_disks < 4)
			errx(EXIT_FAILURE, "4 disks are required at least for "
			    "this RAID level");

		if (argc == 7) {
			if (volsize >
			    ((disksize * user_disks) - (disksize * 2)))
				err(EXIT_FAILURE, "volume size specified "
				    "is larger than available on free disks");
			bc.bc_size = (uint64_t)volsize;
		} else
			bc.bc_size =
			    (((disksize * user_disks) - (disksize * 2)));

		break;
	default:
		errx(EXIT_FAILURE, "Unsupported RAID level");
	}

	bc.bc_channel = location.channel;
	bc.bc_target = location.target;
	bc.bc_lun = location.lun;

	if (ioctl(fd, BIOCVOLOPS, &bc) == -1)
		err(EXIT_FAILURE, "BIOCVOLOPS");

        humanize_number(size, 5, bc.bc_size, "", HN_AUTOSCALE,
	    HN_B | HN_NOSPACE | HN_DECIMAL);

	if (bc.bc_level == BIOC_SVOL_RAID10)
		snprintf(levelstr, sizeof(levelstr), "1+0");
	else
		snprintf(levelstr, sizeof(levelstr), "%u", bc.bc_level);

	printf("Created volume %u size: %s stripe: %uK level: %s "
	    "SCSI location: %u:%u.%u\n", bc.bc_volid, size, bc.bc_stripe,
	    levelstr, bc.bc_channel, bc.bc_target, bc.bc_lun);
}

#ifdef notyet
/*
 * To modify a RAID volume.
 */
static void
bio_volops_modify(int fd, int argc, char **argv)
{
	/* XTRAEME: TODO */
}
#endif

/*
 * To remove a RAID volume.
 */
static void
bio_volops_remove(int fd, int argc, char **argv)
{
	struct bioc_volops	bc;
	struct locator		location;
	const char		*errstr;
	char			*endptr;

	if (argc != 3 || strcmp(argv[0], "volume") != 0)
		usage();

	memset(&bc, 0, sizeof(bc));
	bc.bc_cookie = bl.bl_cookie;
	bc.bc_opcode = BIOC_VREMOVE_VOLUME;

	bc.bc_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
	if (*endptr != '\0')
		errx(EXIT_FAILURE, "Invalid Volume ID value");

	errstr = str2locator(argv[2], &location);
	if (errstr)
		errx(EXIT_FAILURE, "Target %s: %s", argv[2], errstr);

	bc.bc_channel = location.channel;
	bc.bc_target = location.target;
	bc.bc_lun = location.lun;

	if (ioctl(fd, BIOCVOLOPS, &bc) == -1)
		err(EXIT_FAILURE, "BIOCVOLOPS");

	printf("Removed volume %u at SCSI location %u:%u.%u\n",
	    bc.bc_volid, bc.bc_channel, bc.bc_target, bc.bc_lun);
}

/*
 * To blink/unblink a disk in enclosures.
 */
static void
bio_setblink(int fd, int argc, char **argv)
{
	struct locator		location;
	struct bioc_inq		bi;
	struct bioc_vol		bv;
	struct bioc_disk	bd;
	struct bioc_blink	bb;
	const char		*errstr;
	int			v, d, rv, blink = 0;

	if (argc != 2)
		usage();

	if (strcmp(argv[0], "start") == 0)
		blink = BIOC_SBBLINK;
	else if (strcmp(argv[0], "stop") == 0)
		blink = BIOC_SBUNBLINK;
	else
		usage();

	errstr = str2locator(argv[1], &location);
	if (errstr)
		errx(EXIT_FAILURE, "Target %s: %s", argv[1], errstr);

	/* try setting blink on the device directly */
	memset(&bb, 0, sizeof(bb));
	bb.bb_cookie = bl.bl_cookie;
	bb.bb_status = blink;
	bb.bb_target = location.target;
	bb.bb_channel = location.channel;
	rv = ioctl(fd, BIOCBLINK, &bb);
	if (rv == 0)
		return;

	/* if the blink didnt work, try to find something that will */
	memset(&bi, 0, sizeof(bi));
	bi.bi_cookie = bl.bl_cookie;
	rv = ioctl(fd, BIOCINQ, &bi);
	if (rv == -1)
		err(EXIT_FAILURE, "BIOCINQ");

	for (v = 0; v < bi.bi_novol; v++) {
		memset(&bv, 0, sizeof(bv));
		bv.bv_cookie = bl.bl_cookie;
		bv.bv_volid = v;
		rv = ioctl(fd, BIOCVOL, &bv);
		if (rv == -1)
			err(EXIT_FAILURE, "BIOCVOL");

		for (d = 0; d < bv.bv_nodisk; d++) {
			memset(&bd, 0, sizeof(bd));
			bd.bd_cookie = bl.bl_cookie;
			bd.bd_volid = v;
			bd.bd_diskid = d;

			rv = ioctl(fd, BIOCDISK, &bd);
			if (rv == -1)
				err(EXIT_FAILURE, "BIOCDISK");

			if (bd.bd_channel == location.channel &&
			    bd.bd_target == location.target &&
			    bd.bd_lun == location.lun) {
				if (bd.bd_procdev[0] != '\0') {
					bio_blink(fd, bd.bd_procdev,
					    location.target, blink);
				} else
					warnx("Disk %s is not in an enclosure",
					   argv[1]);
				return;
			}
		}
	}

	warnx("Disk %s does not exist", argv[1]);
}

static void
bio_blink(int fd, char *enclosure, int target, int blinktype)
{
	struct bio_locate	bio;
	struct bioc_blink	blink;

	bio.bl_name = enclosure;
	if (ioctl(fd, BIOCLOCATE, &bio) == -1)
		errx(EXIT_FAILURE,
		    "Can't locate %s device via /dev/bio", enclosure);

	memset(&blink, 0, sizeof(blink));
	blink.bb_cookie = bio.bl_cookie;
	blink.bb_status = blinktype;
	blink.bb_target = target;

	if (ioctl(fd, BIOCBLINK, &blink) == -1)
		err(EXIT_FAILURE, "BIOCBLINK");
}