xref: /freebsd/usr.sbin/mptutil/mpt_config.c (revision 0957b409a90fd597c1e9124cbaf3edd2b488f4ac)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 2008 Yahoo!, Inc.
5  * All rights reserved.
6  * Written by: John Baldwin <jhb@FreeBSD.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __RCSID("$FreeBSD$");
35 
36 #include <sys/param.h>
37 #include <sys/errno.h>
38 #include <err.h>
39 #include <fcntl.h>
40 #include <libutil.h>
41 #include <paths.h>
42 #ifdef DEBUG
43 #include <stdint.h>
44 #endif
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <unistd.h>
49 #include "mptutil.h"
50 
51 #ifdef DEBUG
52 static void	dump_config(CONFIG_PAGE_RAID_VOL_0 *vol);
53 #endif
54 
55 static long
56 dehumanize(const char *value)
57 {
58         char    *vtp;
59         long    iv;
60 
61         if (value == NULL)
62                 return (0);
63         iv = strtoq(value, &vtp, 0);
64         if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0')) {
65                 return (0);
66         }
67         switch (vtp[0]) {
68         case 't': case 'T':
69                 iv *= 1024;
70                 /* FALLTHROUGH */
71         case 'g': case 'G':
72                 iv *= 1024;
73                 /* FALLTHROUGH */
74         case 'm': case 'M':
75                 iv *= 1024;
76                 /* FALLTHROUGH */
77         case 'k': case 'K':
78                 iv *= 1024;
79                 /* FALLTHROUGH */
80         case '\0':
81                 break;
82         default:
83                 return (0);
84         }
85         return (iv);
86 }
87 
88 /*
89  * Lock the volume by opening its /dev device read/write.  This will
90  * only work if nothing else has it opened (including mounts).  We
91  * leak the fd on purpose since this application is not long-running.
92  */
93 int
94 mpt_lock_volume(U8 VolumeBus, U8 VolumeID)
95 {
96 	char path[MAXPATHLEN];
97 	struct mpt_query_disk qd;
98 	int error, vfd;
99 
100 	error = mpt_query_disk(VolumeBus, VolumeID, &qd);
101 	if (error == ENOENT)
102 		/*
103 		 * This means there isn't a CAM device associated with
104 		 * the volume, and thus it is already implicitly
105 		 * locked, so just return.
106 		 */
107 		return (0);
108 	if (error) {
109 		warnc(error, "Unable to lookup volume device name");
110 		return (error);
111 	}
112 	snprintf(path, sizeof(path), "%s%s", _PATH_DEV, qd.devname);
113 	vfd = open(path, O_RDWR);
114 	if (vfd < 0) {
115 		error = errno;
116 		warn("Unable to lock volume %s", qd.devname);
117 		return (error);
118 	}
119 	return (0);
120 }
121 
122 static int
123 mpt_lock_physdisk(struct mpt_standalone_disk *disk)
124 {
125 	char path[MAXPATHLEN];
126 	int dfd, error;
127 
128 	snprintf(path, sizeof(path), "%s%s", _PATH_DEV, disk->devname);
129 	dfd = open(path, O_RDWR);
130 	if (dfd < 0) {
131 		error = errno;
132 		warn("Unable to lock disk %s", disk->devname);
133 		return (error);
134 	}
135 	return (0);
136 }
137 
138 static int
139 mpt_lookup_standalone_disk(const char *name, struct mpt_standalone_disk *disks,
140     int ndisks, int *index)
141 {
142 	char *cp;
143 	long bus, id;
144 	int i;
145 
146 	/* Check for a raw <bus>:<id> string. */
147 	bus = strtol(name, &cp, 0);
148 	if (*cp == ':') {
149 		id = strtol(cp + 1, &cp, 0);
150 		if (*cp == '\0') {
151 			if (bus < 0 || bus > 0xff || id < 0 || id > 0xff) {
152 				return (EINVAL);
153 			}
154 			for (i = 0; i < ndisks; i++) {
155 				if (disks[i].bus == (U8)bus &&
156 				    disks[i].target == (U8)id) {
157 					*index = i;
158 					return (0);
159 				}
160 			}
161 			return (ENOENT);
162 		}
163 	}
164 
165 	if (name[0] == 'd' && name[1] == 'a') {
166 		for (i = 0; i < ndisks; i++) {
167 			if (strcmp(name, disks[i].devname) == 0) {
168 				*index = i;
169 				return (0);
170 			}
171 		}
172 		return (ENOENT);
173 	}
174 
175 	return (EINVAL);
176 }
177 
178 /*
179  * Mark a standalone disk as being a physical disk.
180  */
181 static int
182 mpt_create_physdisk(int fd, struct mpt_standalone_disk *disk, U8 *PhysDiskNum)
183 {
184 	CONFIG_PAGE_HEADER header;
185 	CONFIG_PAGE_RAID_PHYS_DISK_0 *config_page;
186 	int error;
187 	U32 ActionData;
188 
189 	error = mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_PHYSDISK,
190 	    0, 0, &header, NULL);
191 	if (error)
192 		return (error);
193 	if (header.PageVersion > MPI_RAIDPHYSDISKPAGE0_PAGEVERSION) {
194 		warnx("Unsupported RAID physdisk page 0 version %d",
195 		    header.PageVersion);
196 		return (EOPNOTSUPP);
197 	}
198 	config_page = calloc(1, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0));
199 	config_page->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
200 	config_page->Header.PageNumber = 0;
201 	config_page->Header.PageLength = sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0) /
202 	    4;
203 	config_page->PhysDiskIOC = 0;	/* XXX */
204 	config_page->PhysDiskBus = disk->bus;
205 	config_page->PhysDiskID = disk->target;
206 
207 	/* XXX: Enclosure info for PhysDiskSettings? */
208 	error = mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_PHYSDISK, 0, 0, 0, 0,
209 	    config_page, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0), NULL,
210 	    &ActionData, sizeof(ActionData), NULL, NULL, 1);
211 	if (error)
212 		return (error);
213 	*PhysDiskNum = ActionData & 0xff;
214 	return (0);
215 }
216 
217 static int
218 mpt_delete_physdisk(int fd, U8 PhysDiskNum)
219 {
220 
221 	return (mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_PHYSDISK, 0, 0,
222 	    PhysDiskNum, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, 0));
223 }
224 
225 /*
226  * MPT's firmware does not have a clear command.  Instead, we
227  * implement it by deleting each array and disk by hand.
228  */
229 static int
230 clear_config(int ac, char **av)
231 {
232 	CONFIG_PAGE_IOC_2 *ioc2;
233 	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
234 	CONFIG_PAGE_IOC_3 *ioc3;
235 	IOC_3_PHYS_DISK *disk;
236 	CONFIG_PAGE_IOC_5 *ioc5;
237 	IOC_5_HOT_SPARE *spare;
238 	int ch, error, fd, i;
239 
240 	fd = mpt_open(mpt_unit);
241 	if (fd < 0) {
242 		error = errno;
243 		warn("mpt_open");
244 		return (error);
245 	}
246 
247 	ioc2 = mpt_read_ioc_page(fd, 2, NULL);
248 	if (ioc2 == NULL) {
249 		error = errno;
250 		warn("Failed to fetch volume list");
251 		close(fd);
252 		return (error);
253 	}
254 
255 	/* Lock all the volumes first. */
256 	vol = ioc2->RaidVolume;
257 	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
258 		if (mpt_lock_volume(vol->VolumeBus, vol->VolumeID) < 0) {
259 			warnx("Volume %s is busy and cannot be deleted",
260 			    mpt_volume_name(vol->VolumeBus, vol->VolumeID));
261 			free(ioc2);
262 			close(fd);
263 			return (EBUSY);
264 		}
265 	}
266 
267 	printf(
268 	    "Are you sure you wish to clear the configuration on mpt%u? [y/N] ",
269 	    mpt_unit);
270 	ch = getchar();
271 	if (ch != 'y' && ch != 'Y') {
272 		printf("\nAborting\n");
273 		free(ioc2);
274 		close(fd);
275 		return (0);
276 	}
277 
278 	/* Delete all the volumes. */
279 	vol = ioc2->RaidVolume;
280 	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
281 		error = mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME,
282 		    vol->VolumeBus, vol->VolumeID, 0,
283 		    MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
284 		    MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0,
285 		    NULL, NULL, 0);
286 		if (error)
287 			warnc(error, "Failed to delete volume %s",
288 			    mpt_volume_name(vol->VolumeBus, vol->VolumeID));
289 	}
290 	free(ioc2);
291 
292 	/* Delete all the spares. */
293 	ioc5 = mpt_read_ioc_page(fd, 5, NULL);
294 	if (ioc5 == NULL)
295 		warn("Failed to fetch spare list");
296 	else {
297 		spare = ioc5->HotSpare;
298 		for (i = 0; i < ioc5->NumHotSpares; spare++, i++)
299 			if (mpt_delete_physdisk(fd, spare->PhysDiskNum) < 0)
300 				warn("Failed to delete physical disk %d",
301 				    spare->PhysDiskNum);
302 		free(ioc5);
303 	}
304 
305 	/* Delete any RAID physdisks that may be left. */
306 	ioc3 = mpt_read_ioc_page(fd, 3, NULL);
307 	if (ioc3 == NULL)
308 		warn("Failed to fetch drive list");
309 	else {
310 		disk = ioc3->PhysDisk;
311 		for (i = 0; i < ioc3->NumPhysDisks; disk++, i++)
312 			if (mpt_delete_physdisk(fd, disk->PhysDiskNum) < 0)
313 				warn("Failed to delete physical disk %d",
314 				    disk->PhysDiskNum);
315 		free(ioc3);
316 	}
317 
318 	printf("mpt%d: Configuration cleared\n", mpt_unit);
319 	mpt_rescan_bus(-1, -1);
320 	close(fd);
321 
322 	return (0);
323 }
324 MPT_COMMAND(top, clear, clear_config);
325 
326 #define	RT_RAID0	0
327 #define	RT_RAID1	1
328 #define	RT_RAID1E	2
329 
330 static struct raid_type_entry {
331 	const char *name;
332 	int	raid_type;
333 } raid_type_table[] = {
334 	{ "raid0",	RT_RAID0 },
335 	{ "raid-0",	RT_RAID0 },
336 	{ "raid1",	RT_RAID1 },
337 	{ "raid-1",	RT_RAID1 },
338 	{ "mirror",	RT_RAID1 },
339 	{ "raid1e",	RT_RAID1E },
340 	{ "raid-1e",	RT_RAID1E },
341 	{ NULL,		0 },
342 };
343 
344 struct config_id_state {
345 	struct mpt_standalone_disk *sdisks;
346 	struct mpt_drive_list *list;
347 	CONFIG_PAGE_IOC_2 *ioc2;
348 	U8	target_id;
349 	int	nsdisks;
350 };
351 
352 struct drive_info {
353 	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
354 	struct mpt_standalone_disk *sdisk;
355 };
356 
357 struct volume_info {
358 	int	drive_count;
359 	struct drive_info *drives;
360 };
361 
362 /* Parse a comma-separated list of drives for a volume. */
363 static int
364 parse_volume(int fd, int raid_type, struct config_id_state *state,
365     char *volume_str, struct volume_info *info)
366 {
367 	struct drive_info *dinfo;
368 	U8 PhysDiskNum;
369 	char *cp;
370 	int count, error, i;
371 
372 	cp = volume_str;
373 	for (count = 0; cp != NULL; count++) {
374 		cp = strchr(cp, ',');
375 		if (cp != NULL) {
376 			cp++;
377 			if (*cp == ',') {
378 				warnx("Invalid drive list '%s'", volume_str);
379 				return (EINVAL);
380 			}
381 		}
382 	}
383 
384 	/* Validate the number of drives for this volume. */
385 	switch (raid_type) {
386 	case RT_RAID0:
387 		if (count < 2) {
388 			warnx("RAID0 requires at least 2 drives in each "
389 			    "array");
390 			return (EINVAL);
391 		}
392 		break;
393 	case RT_RAID1:
394 		if (count != 2) {
395 			warnx("RAID1 requires exactly 2 drives in each "
396 			    "array");
397 			return (EINVAL);
398 		}
399 		break;
400 	case RT_RAID1E:
401 		if (count < 3) {
402 			warnx("RAID1E requires at least 3 drives in each "
403 			    "array");
404 			return (EINVAL);
405 		}
406 		break;
407 	}
408 
409 	/* Validate each drive. */
410 	info->drives = calloc(count, sizeof(struct drive_info));
411 	info->drive_count = count;
412 	for (dinfo = info->drives; (cp = strsep(&volume_str, ",")) != NULL;
413 	     dinfo++) {
414 		/* If this drive is already a RAID phys just fetch the info. */
415 		error = mpt_lookup_drive(state->list, cp, &PhysDiskNum);
416 		if (error == 0) {
417 			dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
418 			if (dinfo->info == NULL)
419 				return (errno);
420 			continue;
421 		}
422 
423 		/* See if it is a standalone disk. */
424 		if (mpt_lookup_standalone_disk(cp, state->sdisks,
425 		    state->nsdisks, &i) < 0) {
426 			error = errno;
427 			warn("Unable to lookup drive %s", cp);
428 			return (error);
429 		}
430 		dinfo->sdisk = &state->sdisks[i];
431 
432 		/* Lock the disk, we will create phys disk pages later. */
433 		if (mpt_lock_physdisk(dinfo->sdisk) < 0)
434 			return (errno);
435 	}
436 
437 	return (0);
438 }
439 
440 /*
441  * Add RAID physdisk pages for any standalone disks that a volume is
442  * going to use.
443  */
444 static int
445 add_drives(int fd, struct volume_info *info, int verbose)
446 {
447 	struct drive_info *dinfo;
448 	U8 PhysDiskNum;
449 	int error, i;
450 
451 	for (i = 0, dinfo = info->drives; i < info->drive_count;
452 	     i++, dinfo++) {
453 		if (dinfo->info == NULL) {
454 			if (mpt_create_physdisk(fd, dinfo->sdisk,
455 			    &PhysDiskNum) < 0) {
456 				error = errno;
457 				warn(
458 			    "Failed to create physical disk page for %s",
459 				    dinfo->sdisk->devname);
460 				return (error);
461 			}
462 			if (verbose)
463 				printf("Added drive %s with PhysDiskNum %u\n",
464 				    dinfo->sdisk->devname, PhysDiskNum);
465 
466 			dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
467 			if (dinfo->info == NULL)
468 				return (errno);
469 		}
470 	}
471 	return (0);
472 }
473 
474 /*
475  * Find the next free target ID assuming that 'target_id' is the last
476  * one used.  'target_id' should be 0xff for the initial test.
477  */
478 static U8
479 find_next_volume(struct config_id_state *state)
480 {
481 	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
482 	int i;
483 
484 restart:
485 	/* Assume the current one is used. */
486 	state->target_id++;
487 
488 	/* Search drives first. */
489 	for (i = 0; i < state->nsdisks; i++)
490 		if (state->sdisks[i].target == state->target_id)
491 			goto restart;
492 	for (i = 0; i < state->list->ndrives; i++)
493 		if (state->list->drives[i]->PhysDiskID == state->target_id)
494 			goto restart;
495 
496 	/* Search volumes second. */
497 	vol = state->ioc2->RaidVolume;
498 	for (i = 0; i < state->ioc2->NumActiveVolumes; vol++, i++)
499 		if (vol->VolumeID == state->target_id)
500 			goto restart;
501 
502 	return (state->target_id);
503 }
504 
505 /* Create a volume and populate it with drives. */
506 static CONFIG_PAGE_RAID_VOL_0 *
507 build_volume(int fd, struct volume_info *info, int raid_type, long stripe_size,
508     struct config_id_state *state, int verbose)
509 {
510 	CONFIG_PAGE_HEADER header;
511 	CONFIG_PAGE_RAID_VOL_0 *vol;
512 	RAID_VOL0_PHYS_DISK *rdisk;
513 	struct drive_info *dinfo;
514         U32 MinLBA;
515 	uint64_t MaxLBA;
516 	size_t page_size;
517 	int error, i;
518 
519 	error = mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_VOLUME,
520 	    0, 0, &header, NULL);
521 	if (error) {
522 		errno = error;
523 		return (NULL);
524 	}
525 	if (header.PageVersion > MPI_RAIDVOLPAGE0_PAGEVERSION) {
526 		warnx("Unsupported RAID volume page 0 version %d",
527 		    header.PageVersion);
528 		errno = EOPNOTSUPP;
529 		return (NULL);
530 	}
531 	page_size = sizeof(CONFIG_PAGE_RAID_VOL_0) +
532 	    sizeof(RAID_VOL0_PHYS_DISK) * (info->drive_count - 1);
533 	vol = calloc(1, page_size);
534 	if (vol == NULL)
535 		return (NULL);
536 
537 	/* Header */
538 	vol->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
539 	vol->Header.PageNumber = 0;
540 	vol->Header.PageLength = page_size / 4;
541 
542 	/* Properties */
543 	vol->VolumeID = find_next_volume(state);
544 	vol->VolumeBus = 0;
545 	vol->VolumeIOC = 0;	/* XXX */
546 	vol->VolumeStatus.Flags = MPI_RAIDVOL0_STATUS_FLAG_ENABLED;
547 	vol->VolumeStatus.State = MPI_RAIDVOL0_STATUS_STATE_OPTIMAL;
548 	vol->VolumeSettings.Settings = MPI_RAIDVOL0_SETTING_USE_DEFAULTS;
549 	vol->VolumeSettings.HotSparePool = MPI_RAID_HOT_SPARE_POOL_0;
550 	vol->NumPhysDisks = info->drive_count;
551 
552 	/* Find the smallest drive. */
553 	MinLBA = info->drives[0].info->MaxLBA;
554 	for (i = 1; i < info->drive_count; i++)
555 		if (info->drives[i].info->MaxLBA < MinLBA)
556 			MinLBA = info->drives[i].info->MaxLBA;
557 
558 	/*
559 	 * Now chop off 512MB at the end to leave room for the
560 	 * metadata.  The controller might only use 64MB, but we just
561 	 * chop off the max to be simple.
562 	 */
563 	MinLBA -= (512 * 1024 * 1024) / 512;
564 
565 	switch (raid_type) {
566 	case RT_RAID0:
567 		vol->VolumeType = MPI_RAID_VOL_TYPE_IS;
568 		vol->StripeSize = stripe_size / 512;
569 		MaxLBA = (uint64_t)MinLBA * info->drive_count;
570 		break;
571 	case RT_RAID1:
572 		vol->VolumeType = MPI_RAID_VOL_TYPE_IM;
573 		MaxLBA = (uint64_t)MinLBA * (info->drive_count / 2);
574 		break;
575 	case RT_RAID1E:
576 		vol->VolumeType = MPI_RAID_VOL_TYPE_IME;
577 		vol->StripeSize = stripe_size / 512;
578 		MaxLBA = (uint64_t)MinLBA * info->drive_count / 2;
579 		break;
580 	default:
581 		/* Pacify gcc. */
582 		abort();
583 	}
584 
585 	/*
586 	 * If the controller doesn't support 64-bit addressing and the
587 	 * new volume is larger than 2^32 blocks, warn the user and
588 	 * truncate the volume.
589 	 */
590 	if (MaxLBA >> 32 != 0 &&
591 	    !(state->ioc2->CapabilitiesFlags &
592 	    MPI_IOCPAGE2_CAP_FLAGS_RAID_64_BIT_ADDRESSING)) {
593 		warnx(
594 	    "Controller does not support volumes > 2TB, truncating volume.");
595 		MaxLBA = 0xffffffff;
596 	}
597 	vol->MaxLBA = MaxLBA;
598 	vol->MaxLBAHigh = MaxLBA >> 32;
599 
600 	/* Populate drives. */
601 	for (i = 0, dinfo = info->drives, rdisk = vol->PhysDisk;
602 	     i < info->drive_count; i++, dinfo++, rdisk++) {
603 		if (verbose)
604 			printf("Adding drive %u (%u:%u) to volume %u:%u\n",
605 			    dinfo->info->PhysDiskNum, dinfo->info->PhysDiskBus,
606 			    dinfo->info->PhysDiskID, vol->VolumeBus,
607 			    vol->VolumeID);
608 		if (raid_type == RT_RAID1) {
609 			if (i == 0)
610 				rdisk->PhysDiskMap =
611 				    MPI_RAIDVOL0_PHYSDISK_PRIMARY;
612 			else
613 				rdisk->PhysDiskMap =
614 				    MPI_RAIDVOL0_PHYSDISK_SECONDARY;
615 		} else
616 			rdisk->PhysDiskMap = i;
617 		rdisk->PhysDiskNum = dinfo->info->PhysDiskNum;
618 	}
619 
620 	return (vol);
621 }
622 
623 static int
624 create_volume(int ac, char **av)
625 {
626 	CONFIG_PAGE_RAID_VOL_0 *vol;
627 	struct config_id_state state;
628 	struct volume_info *info;
629 	long stripe_size;
630 	int ch, error, fd, i, quick, raid_type, verbose;
631 #ifdef DEBUG
632 	int dump;
633 #endif
634 
635 	if (ac < 2) {
636 		warnx("create: volume type required");
637 		return (EINVAL);
638 	}
639 
640 	fd = mpt_open(mpt_unit);
641 	if (fd < 0) {
642 		error = errno;
643 		warn("mpt_open");
644 		return (error);
645 	}
646 
647 	/* Lookup the RAID type first. */
648 	raid_type = -1;
649 	for (i = 0; raid_type_table[i].name != NULL; i++)
650 		if (strcasecmp(raid_type_table[i].name, av[1]) == 0) {
651 			raid_type = raid_type_table[i].raid_type;
652 			break;
653 		}
654 
655 	if (raid_type == -1) {
656 		warnx("Unknown or unsupported volume type %s", av[1]);
657 		close(fd);
658 		return (EINVAL);
659 	}
660 
661 	/* Parse any options. */
662 	optind = 2;
663 #ifdef DEBUG
664 	dump = 0;
665 #endif
666 	quick = 0;
667 	verbose = 0;
668 	stripe_size = 64 * 1024;
669 
670 	while ((ch = getopt(ac, av, "dqs:v")) != -1) {
671 		switch (ch) {
672 #ifdef DEBUG
673 		case 'd':
674 			dump = 1;
675 			break;
676 #endif
677 		case 'q':
678 			quick = 1;
679 			break;
680 		case 's':
681 			stripe_size = dehumanize(optarg);
682 			if ((stripe_size < 512) || (!powerof2(stripe_size))) {
683 				warnx("Invalid stripe size %s", optarg);
684 				close(fd);
685 				return (EINVAL);
686 			}
687 			break;
688 		case 'v':
689 			verbose = 1;
690 			break;
691 		case '?':
692 		default:
693 			close(fd);
694 			return (EINVAL);
695 		}
696 	}
697 	ac -= optind;
698 	av += optind;
699 
700 	/* Fetch existing config data. */
701 	state.ioc2 = mpt_read_ioc_page(fd, 2, NULL);
702 	if (state.ioc2 == NULL) {
703 		error = errno;
704 		warn("Failed to read volume list");
705 		close(fd);
706 		return (error);
707 	}
708 	state.list = mpt_pd_list(fd);
709 	if (state.list == NULL) {
710 		close(fd);
711 		return (errno);
712 	}
713 	error = mpt_fetch_disks(fd, &state.nsdisks, &state.sdisks);
714 	if (error) {
715 		warn("Failed to fetch standalone disk list");
716 		close(fd);
717 		return (error);
718 	}
719 	state.target_id = 0xff;
720 
721 	/* Parse the drive list. */
722 	if (ac != 1) {
723 		warnx("Exactly one drive list is required");
724 		close(fd);
725 		return (EINVAL);
726 	}
727 	info = calloc(1, sizeof(*info));
728 	if (info == NULL) {
729 		close(fd);
730 		return (ENOMEM);
731 	}
732 	error = parse_volume(fd, raid_type, &state, av[0], info);
733 	if (error) {
734 		free(info);
735 		close(fd);
736 		return (error);
737 	}
738 
739 	/* Create RAID physdisk pages for standalone disks. */
740 	error = add_drives(fd, info, verbose);
741 	if (error) {
742 		free(info);
743 		close(fd);
744 		return (error);
745 	}
746 
747 	/* Build the volume. */
748 	vol = build_volume(fd, info, raid_type, stripe_size, &state, verbose);
749 	if (vol == NULL) {
750 		free(info);
751 		close(fd);
752 		return (errno);
753 	}
754 
755 #ifdef DEBUG
756 	if (dump) {
757 		dump_config(vol);
758 		goto skip;
759 	}
760 #endif
761 
762 	/* Send the new volume to the controller. */
763 	error = mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_VOLUME, vol->VolumeBus,
764 	    vol->VolumeID, 0, quick ? MPI_RAID_ACTION_ADATA_DO_NOT_SYNC : 0,
765 	    vol, vol->Header.PageLength * 4, NULL, NULL, 0, NULL, NULL, 1);
766 	if (error) {
767 		errno = error;
768 		warn("Failed to add volume");
769 		free(info);
770 		close(fd);
771 		return (error);
772 	}
773 
774 #ifdef DEBUG
775 skip:
776 #endif
777 	mpt_rescan_bus(vol->VolumeBus, vol->VolumeID);
778 
779 	/* Clean up. */
780 	free(vol);
781 	free(info);
782 	free(state.sdisks);
783 	mpt_free_pd_list(state.list);
784 	free(state.ioc2);
785 	close(fd);
786 
787 	return (0);
788 }
789 MPT_COMMAND(top, create, create_volume);
790 
791 static int
792 delete_volume(int ac, char **av)
793 {
794 	U8 VolumeBus, VolumeID;
795 	int error, fd;
796 
797 	if (ac != 2) {
798 		warnx("delete: volume required");
799 		return (EINVAL);
800 	}
801 
802 	fd = mpt_open(mpt_unit);
803 	if (fd < 0) {
804 		error = errno;
805 		warn("mpt_open");
806 		return (error);
807 	}
808 
809 	error = mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID);
810 	if (error) {
811 		warnc(error, "Invalid volume %s", av[1]);
812 		close(fd);
813 		return (error);
814 	}
815 
816 	if (mpt_lock_volume(VolumeBus, VolumeID) < 0) {
817 		close(fd);
818 		return (errno);
819 	}
820 
821 	error = mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME, VolumeBus,
822 	    VolumeID, 0, MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
823 	    MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0, NULL,
824 	    NULL, 0);
825 	if (error) {
826 		warnc(error, "Failed to delete volume");
827 		close(fd);
828 		return (error);
829 	}
830 
831 	mpt_rescan_bus(-1, -1);
832 	close(fd);
833 
834 	return (0);
835 }
836 MPT_COMMAND(top, delete, delete_volume);
837 
838 static int
839 find_volume_spare_pool(int fd, const char *name, int *pool)
840 {
841 	CONFIG_PAGE_RAID_VOL_0 *info;
842 	CONFIG_PAGE_IOC_2 *ioc2;
843 	CONFIG_PAGE_IOC_2_RAID_VOL *vol;
844 	U8 VolumeBus, VolumeID;
845 	int error, i, j, new_pool, pool_count[7];
846 
847 	error = mpt_lookup_volume(fd, name, &VolumeBus, &VolumeID);
848 	if (error) {
849 		warnc(error, "Invalid volume %s", name);
850 		return (error);
851 	}
852 
853 	info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
854 	if (info == NULL)
855 		return (errno);
856 
857 	/*
858 	 * Check for an existing pool other than pool 0 (used for
859 	 * global spares).
860 	 */
861 	if ((info->VolumeSettings.HotSparePool & ~MPI_RAID_HOT_SPARE_POOL_0) !=
862 	    0) {
863 		*pool = 1 << (ffs(info->VolumeSettings.HotSparePool &
864 		    ~MPI_RAID_HOT_SPARE_POOL_0) - 1);
865 		free(info);
866 		return (0);
867 	}
868 	free(info);
869 
870 	/*
871 	 * Try to find a free pool.  First, figure out which pools are
872 	 * in use.
873 	 */
874 	ioc2 = mpt_read_ioc_page(fd, 2, NULL);
875 	if (ioc2 == NULL) {
876 		error = errno;
877 		warn("Failed to fetch volume list");
878 		return (error);
879 	}
880 	bzero(pool_count, sizeof(pool_count));
881 	vol = ioc2->RaidVolume;
882 	for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
883 		info = mpt_vol_info(fd, vol->VolumeBus, vol->VolumeID, NULL);
884 		if (info == NULL)
885 			return (errno);
886 		for (j = 0; j < 7; j++)
887 			if (info->VolumeSettings.HotSparePool & (1 << (j + 1)))
888 				pool_count[j]++;
889 		free(info);
890 	}
891 	free(ioc2);
892 
893 	/* Find the pool with the lowest use count. */
894 	new_pool = 0;
895 	for (i = 1; i < 7; i++)
896 		if (pool_count[i] < pool_count[new_pool])
897 			new_pool = i;
898 	new_pool++;
899 
900 	/* Add this pool to the volume. */
901 	info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
902 	if (info == NULL)
903 		return (error);
904 	info->VolumeSettings.HotSparePool |= (1 << new_pool);
905 	error = mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_VOLUME_SETTINGS,
906 	    VolumeBus, VolumeID, 0, *(U32 *)&info->VolumeSettings, NULL, 0,
907 	    NULL, NULL, 0, NULL, NULL, 0);
908 	if (error) {
909 		warnx("Failed to add spare pool %d to %s", new_pool,
910 		    mpt_volume_name(VolumeBus, VolumeID));
911 		free(info);
912 		return (error);
913 	}
914 	free(info);
915 
916 	*pool = (1 << new_pool);
917 	return (0);
918 }
919 
920 static int
921 add_spare(int ac, char **av)
922 {
923 	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
924 	struct mpt_standalone_disk *sdisks;
925 	struct mpt_drive_list *list;
926 	U8 PhysDiskNum;
927 	int error, fd, i, nsdisks, pool;
928 
929 	if (ac < 2) {
930 		warnx("add spare: drive required");
931 		return (EINVAL);
932 	}
933 	if (ac > 3) {
934 		warnx("add spare: extra arguments");
935 		return (EINVAL);
936 	}
937 
938 	fd = mpt_open(mpt_unit);
939 	if (fd < 0) {
940 		error = errno;
941 		warn("mpt_open");
942 		return (error);
943 	}
944 
945 	if (ac == 3) {
946 		error = find_volume_spare_pool(fd, av[2], &pool);
947 		if (error) {
948 			close(fd);
949 			return (error);
950 		}
951 	} else
952 		pool = MPI_RAID_HOT_SPARE_POOL_0;
953 
954 	list = mpt_pd_list(fd);
955 	if (list == NULL)
956 		return (errno);
957 
958 	error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
959 	if (error) {
960 		error = mpt_fetch_disks(fd, &nsdisks, &sdisks);
961 		if (error != 0) {
962 			warn("Failed to fetch standalone disk list");
963 			mpt_free_pd_list(list);
964 			close(fd);
965 			return (error);
966 		}
967 
968 		if (mpt_lookup_standalone_disk(av[1], sdisks, nsdisks, &i) <
969 		    0) {
970 			error = errno;
971 			warn("Unable to lookup drive %s", av[1]);
972 			mpt_free_pd_list(list);
973 			close(fd);
974 			return (error);
975 		}
976 
977 		if (mpt_lock_physdisk(&sdisks[i]) < 0) {
978 			mpt_free_pd_list(list);
979 			close(fd);
980 			return (errno);
981 		}
982 
983 		if (mpt_create_physdisk(fd, &sdisks[i], &PhysDiskNum) < 0) {
984 			error = errno;
985 			warn("Failed to create physical disk page");
986 			mpt_free_pd_list(list);
987 			close(fd);
988 			return (error);
989 		}
990 		free(sdisks);
991 	}
992 	mpt_free_pd_list(list);
993 
994 	info = mpt_pd_info(fd, PhysDiskNum, NULL);
995 	if (info == NULL) {
996 		error = errno;
997 		warn("Failed to fetch drive info");
998 		close(fd);
999 		return (error);
1000 	}
1001 
1002 	info->PhysDiskSettings.HotSparePool = pool;
1003 	error = mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_PHYSDISK_SETTINGS, 0,
1004 	    0, PhysDiskNum, *(U32 *)&info->PhysDiskSettings, NULL, 0, NULL,
1005 	    NULL, 0, NULL, NULL, 0);
1006 	if (error) {
1007 		warnc(error, "Failed to assign spare");
1008 		close(fd);
1009 		return (error);
1010 	}
1011 
1012 	free(info);
1013 	close(fd);
1014 
1015 	return (0);
1016 }
1017 MPT_COMMAND(top, add, add_spare);
1018 
1019 static int
1020 remove_spare(int ac, char **av)
1021 {
1022 	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
1023 	struct mpt_drive_list *list;
1024 	U8 PhysDiskNum;
1025 	int error, fd;
1026 
1027 	if (ac != 2) {
1028 		warnx("remove spare: drive required");
1029 		return (EINVAL);
1030 	}
1031 
1032 	fd = mpt_open(mpt_unit);
1033 	if (fd < 0) {
1034 		error = errno;
1035 		warn("mpt_open");
1036 		return (error);
1037 	}
1038 
1039 	list = mpt_pd_list(fd);
1040 	if (list == NULL) {
1041 		close(fd);
1042 		return (errno);
1043 	}
1044 
1045 	error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
1046 	if (error) {
1047 		warn("Failed to find drive %s", av[1]);
1048 		close(fd);
1049 		return (error);
1050 	}
1051 	mpt_free_pd_list(list);
1052 
1053 
1054 	info = mpt_pd_info(fd, PhysDiskNum, NULL);
1055 	if (info == NULL) {
1056 		error = errno;
1057 		warn("Failed to fetch drive info");
1058 		close(fd);
1059 		return (error);
1060 	}
1061 
1062 	if (info->PhysDiskSettings.HotSparePool == 0) {
1063 		warnx("Drive %u is not a hot spare", PhysDiskNum);
1064 		free(info);
1065 		close(fd);
1066 		return (EINVAL);
1067 	}
1068 
1069 	if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
1070 		error = errno;
1071 		warn("Failed to delete physical disk page");
1072 		free(info);
1073 		close(fd);
1074 		return (error);
1075 	}
1076 
1077 	mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
1078 	free(info);
1079 	close(fd);
1080 
1081 	return (0);
1082 }
1083 MPT_COMMAND(top, remove, remove_spare);
1084 
1085 #ifdef DEBUG
1086 MPT_TABLE(top, pd);
1087 
1088 static int
1089 pd_create(int ac, char **av)
1090 {
1091 	struct mpt_standalone_disk *disks;
1092 	int error, fd, i, ndisks;
1093 	U8 PhysDiskNum;
1094 
1095 	if (ac != 2) {
1096 		warnx("pd create: drive required");
1097 		return (EINVAL);
1098 	}
1099 
1100 	fd = mpt_open(mpt_unit);
1101 	if (fd < 0) {
1102 		error = errno;
1103 		warn("mpt_open");
1104 		return (error);
1105 	}
1106 
1107 	error = mpt_fetch_disks(fd, &ndisks, &disks);
1108 	if (error != 0) {
1109 		warn("Failed to fetch standalone disk list");
1110 		return (error);
1111 	}
1112 
1113 	if (mpt_lookup_standalone_disk(av[1], disks, ndisks, &i) < 0) {
1114 		error = errno;
1115 		warn("Unable to lookup drive");
1116 		return (error);
1117 	}
1118 
1119 	if (mpt_lock_physdisk(&disks[i]) < 0)
1120 		return (errno);
1121 
1122 	if (mpt_create_physdisk(fd, &disks[i], &PhysDiskNum) < 0) {
1123 		error = errno;
1124 		warn("Failed to create physical disk page");
1125 		return (error);
1126 	}
1127 	free(disks);
1128 
1129 	printf("Added drive %s with PhysDiskNum %u\n", av[1], PhysDiskNum);
1130 
1131 	close(fd);
1132 
1133 	return (0);
1134 }
1135 MPT_COMMAND(pd, create, pd_create);
1136 
1137 static int
1138 pd_delete(int ac, char **av)
1139 {
1140 	CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
1141 	struct mpt_drive_list *list;
1142 	int error, fd;
1143 	U8 PhysDiskNum;
1144 
1145 	if (ac != 2) {
1146 		warnx("pd delete: drive required");
1147 		return (EINVAL);
1148 	}
1149 
1150 	fd = mpt_open(mpt_unit);
1151 	if (fd < 0) {
1152 		error = errno;
1153 		warn("mpt_open");
1154 		return (error);
1155 	}
1156 
1157 	list = mpt_pd_list(fd);
1158 	if (list == NULL)
1159 		return (errno);
1160 
1161 	if (mpt_lookup_drive(list, av[1], &PhysDiskNum) < 0) {
1162 		error = errno;
1163 		warn("Failed to find drive %s", av[1]);
1164 		return (error);
1165 	}
1166 	mpt_free_pd_list(list);
1167 
1168 	info = mpt_pd_info(fd, PhysDiskNum, NULL);
1169 	if (info == NULL) {
1170 		error = errno;
1171 		warn("Failed to fetch drive info");
1172 		return (error);
1173 	}
1174 
1175 	if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
1176 		error = errno;
1177 		warn("Failed to delete physical disk page");
1178 		return (error);
1179 	}
1180 
1181 	mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
1182 	free(info);
1183 	close(fd);
1184 
1185 	return (0);
1186 }
1187 MPT_COMMAND(pd, delete, pd_delete);
1188 
1189 /* Display raw data about a volume config. */
1190 static void
1191 dump_config(CONFIG_PAGE_RAID_VOL_0 *vol)
1192 {
1193 	int i;
1194 
1195 	printf("Volume Configuration (Debug):\n");
1196 	printf(
1197    " Page Header: Type 0x%02x Number 0x%02x Length 0x%02x(%u) Version 0x%02x\n",
1198 	    vol->Header.PageType, vol->Header.PageNumber,
1199 	    vol->Header.PageLength, vol->Header.PageLength * 4,
1200 	    vol->Header.PageVersion);
1201 	printf("     Address: %d:%d IOC %d\n", vol->VolumeBus, vol->VolumeID,
1202 	    vol->VolumeIOC);
1203 	printf("        Type: %d (%s)\n", vol->VolumeType,
1204 	    mpt_raid_level(vol->VolumeType));
1205 	printf("      Status: %s (Flags 0x%02x)\n",
1206 	    mpt_volstate(vol->VolumeStatus.State), vol->VolumeStatus.Flags);
1207 	printf("    Settings: 0x%04x (Spare Pools 0x%02x)\n",
1208 	    vol->VolumeSettings.Settings, vol->VolumeSettings.HotSparePool);
1209 	printf("      MaxLBA: %ju\n", (uintmax_t)vol->MaxLBAHigh << 32 |
1210 	    vol->MaxLBA);
1211 	printf(" Stripe Size: %ld\n", (long)vol->StripeSize * 512);
1212 	printf(" %d Disks:\n", vol->NumPhysDisks);
1213 
1214 	for (i = 0; i < vol->NumPhysDisks; i++)
1215 		printf("    Disk %d: Num 0x%02x Map 0x%02x\n", i,
1216 		    vol->PhysDisk[i].PhysDiskNum, vol->PhysDisk[i].PhysDiskMap);
1217 }
1218 
1219 static int
1220 debug_config(int ac, char **av)
1221 {
1222 	CONFIG_PAGE_RAID_VOL_0 *vol;
1223 	U8 VolumeBus, VolumeID;
1224 	int error, fd;
1225 
1226 	if (ac != 2) {
1227 		warnx("debug: volume required");
1228 		return (EINVAL);
1229 	}
1230 
1231 	fd = mpt_open(mpt_unit);
1232 	if (fd < 0) {
1233 		error = errno;
1234 		warn("mpt_open");
1235 		return (error);
1236 	}
1237 
1238 	error = mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID);
1239 	if (error) {
1240 		warnc(error, "Invalid volume: %s", av[1]);
1241 		return (error);
1242 	}
1243 
1244 	vol = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
1245 	if (vol == NULL) {
1246 		error = errno;
1247 		warn("Failed to get volume info");
1248 		return (error);
1249 	}
1250 
1251 	dump_config(vol);
1252 	free(vol);
1253 	close(fd);
1254 
1255 	return (0);
1256 }
1257 MPT_COMMAND(top, debug, debug_config);
1258 #endif
1259