mfi_config.c revision 222899 
1/*-
2 * Copyright (c) 2008, 2009 Yahoo!, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. The names of the authors may not be used to endorse or promote
14 *    products derived from this software without specific prior written
15 *    permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: head/usr.sbin/mfiutil/mfi_config.c 222899 2011-06-09 19:52:28Z bz $
30 */
31
32#include <sys/param.h>
33#ifdef DEBUG
34#include <sys/sysctl.h>
35#endif
36#include <err.h>
37#include <errno.h>
38#include <libutil.h>
39#ifdef DEBUG
40#include <stdint.h>
41#endif
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include <unistd.h>
46#include "mfiutil.h"
47
48#ifdef DEBUG
49static void	dump_config(int fd, struct mfi_config_data *config);
50#endif
51
52static int	add_spare(int ac, char **av);
53static int	remove_spare(int ac, char **av);
54
55static long
56dehumanize(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        case 'g': case 'G':
71                iv *= 1024;
72        case 'm': case 'M':
73                iv *= 1024;
74        case 'k': case 'K':
75                iv *= 1024;
76        case '\0':
77                break;
78        default:
79                return (0);
80        }
81        return (iv);
82}
83int
84mfi_config_read(int fd, struct mfi_config_data **configp)
85{
86	struct mfi_config_data *config;
87	uint32_t config_size;
88	int error;
89
90	/*
91	 * Keep fetching the config in a loop until we have a large enough
92	 * buffer to hold the entire configuration.
93	 */
94	config = NULL;
95	config_size = 1024;
96fetch:
97	config = reallocf(config, config_size);
98	if (config == NULL)
99		return (-1);
100	if (mfi_dcmd_command(fd, MFI_DCMD_CFG_READ, config,
101	    config_size, NULL, 0, NULL) < 0) {
102		error = errno;
103		free(config);
104		errno = error;
105		return (-1);
106	}
107
108	if (config->size > config_size) {
109		config_size = config->size;
110		goto fetch;
111	}
112
113	*configp = config;
114	return (0);
115}
116
117static struct mfi_array *
118mfi_config_lookup_array(struct mfi_config_data *config, uint16_t array_ref)
119{
120	struct mfi_array *ar;
121	char *p;
122	int i;
123
124	p = (char *)config->array;
125	for (i = 0; i < config->array_count; i++) {
126		ar = (struct mfi_array *)p;
127		if (ar->array_ref == array_ref)
128			return (ar);
129		p += config->array_size;
130	}
131
132	return (NULL);
133}
134
135static struct mfi_ld_config *
136mfi_config_lookup_volume(struct mfi_config_data *config, uint8_t target_id)
137{
138	struct mfi_ld_config *ld;
139	char *p;
140	int i;
141
142	p = (char *)config->array + config->array_count * config->array_size;
143	for (i = 0; i < config->log_drv_count; i++) {
144		ld = (struct mfi_ld_config *)p;
145		if (ld->properties.ld.v.target_id == target_id)
146			return (ld);
147		p += config->log_drv_size;
148	}
149
150	return (NULL);
151}
152
153static int
154clear_config(int ac, char **av)
155{
156	struct mfi_ld_list list;
157	int ch, error, fd;
158	u_int i;
159
160	fd = mfi_open(mfi_unit);
161	if (fd < 0) {
162		error = errno;
163		warn("mfi_open");
164		return (error);
165	}
166
167	if (!mfi_reconfig_supported()) {
168		warnx("The current mfi(4) driver does not support "
169		    "configuration changes.");
170		close(fd);
171		return (EOPNOTSUPP);
172	}
173
174	if (mfi_ld_get_list(fd, &list, NULL) < 0) {
175		error = errno;
176		warn("Failed to get volume list");
177		close(fd);
178		return (error);
179	}
180
181	for (i = 0; i < list.ld_count; i++) {
182		if (mfi_volume_busy(fd, list.ld_list[i].ld.v.target_id)) {
183			warnx("Volume %s is busy and cannot be deleted",
184			    mfi_volume_name(fd, list.ld_list[i].ld.v.target_id));
185			close(fd);
186			return (EBUSY);
187		}
188	}
189
190	printf(
191	    "Are you sure you wish to clear the configuration on mfi%u? [y/N] ",
192	    mfi_unit);
193	ch = getchar();
194	if (ch != 'y' && ch != 'Y') {
195		printf("\nAborting\n");
196		close(fd);
197		return (0);
198	}
199
200	if (mfi_dcmd_command(fd, MFI_DCMD_CFG_CLEAR, NULL, 0, NULL, 0, NULL) < 0) {
201		error = errno;
202		warn("Failed to clear configuration");
203		close(fd);
204		return (error);
205	}
206
207	printf("mfi%d: Configuration cleared\n", mfi_unit);
208	close(fd);
209
210	return (0);
211}
212MFI_COMMAND(top, clear, clear_config);
213
214#define	MFI_ARRAY_SIZE		288
215#define	MAX_DRIVES_PER_ARRAY						\
216	((MFI_ARRAY_SIZE - sizeof(struct mfi_array)) / 8)
217
218#define	RT_RAID0	0
219#define	RT_RAID1	1
220#define	RT_RAID5	2
221#define	RT_RAID6	3
222#define	RT_JBOD		4
223#define	RT_CONCAT	5
224#define	RT_RAID10	6
225#define	RT_RAID50	7
226#define	RT_RAID60	8
227
228static int
229compare_int(const void *one, const void *two)
230{
231	int first, second;
232
233	first = *(const int *)one;
234	second = *(const int *)two;
235
236	return (first - second);
237}
238
239static struct raid_type_entry {
240	const char *name;
241	int	raid_type;
242} raid_type_table[] = {
243	{ "raid0",	RT_RAID0 },
244	{ "raid-0",	RT_RAID0 },
245	{ "raid1",	RT_RAID1 },
246	{ "raid-1",	RT_RAID1 },
247	{ "mirror",	RT_RAID1 },
248	{ "raid5",	RT_RAID5 },
249	{ "raid-5",	RT_RAID5 },
250	{ "raid6",	RT_RAID6 },
251	{ "raid-6",	RT_RAID6 },
252	{ "jbod",	RT_JBOD },
253	{ "concat",	RT_CONCAT },
254	{ "raid10",	RT_RAID10 },
255	{ "raid1+0",	RT_RAID10 },
256	{ "raid-10",	RT_RAID10 },
257	{ "raid-1+0",	RT_RAID10 },
258	{ "raid50",	RT_RAID50 },
259	{ "raid5+0",	RT_RAID50 },
260	{ "raid-50",	RT_RAID50 },
261	{ "raid-5+0",	RT_RAID50 },
262	{ "raid60",	RT_RAID60 },
263	{ "raid6+0",	RT_RAID60 },
264	{ "raid-60",	RT_RAID60 },
265	{ "raid-6+0",	RT_RAID60 },
266	{ NULL,		0 },
267};
268
269struct config_id_state {
270	int	array_count;
271	int	log_drv_count;
272	int	*arrays;
273	int	*volumes;
274	uint16_t array_ref;
275	uint8_t	target_id;
276};
277
278struct array_info {
279	int	drive_count;
280	struct mfi_pd_info *drives;
281	struct mfi_array *array;
282};
283
284/* Parse a comma-separated list of drives for an array. */
285static int
286parse_array(int fd, int raid_type, char *array_str, struct array_info *info)
287{
288	struct mfi_pd_info *pinfo;
289	uint16_t device_id;
290	char *cp;
291	u_int count;
292	int error;
293
294	cp = array_str;
295	for (count = 0; cp != NULL; count++) {
296		cp = strchr(cp, ',');
297		if (cp != NULL) {
298			cp++;
299			if (*cp == ',') {
300				warnx("Invalid drive list '%s'", array_str);
301				return (EINVAL);
302			}
303		}
304	}
305
306	/* Validate the number of drives for this array. */
307	if (count >= MAX_DRIVES_PER_ARRAY) {
308		warnx("Too many drives for a single array: max is %zu",
309		    MAX_DRIVES_PER_ARRAY);
310		return (EINVAL);
311	}
312	switch (raid_type) {
313	case RT_RAID1:
314	case RT_RAID10:
315		if (count % 2 != 0) {
316			warnx("RAID1 and RAID10 require an even number of "
317			    "drives in each array");
318			return (EINVAL);
319		}
320		break;
321	case RT_RAID5:
322	case RT_RAID50:
323		if (count < 3) {
324			warnx("RAID5 and RAID50 require at least 3 drives in "
325			    "each array");
326			return (EINVAL);
327		}
328		break;
329	case RT_RAID6:
330	case RT_RAID60:
331		if (count < 4) {
332			warnx("RAID6 and RAID60 require at least 4 drives in "
333			    "each array");
334			return (EINVAL);
335		}
336		break;
337	}
338
339	/* Validate each drive. */
340	info->drives = calloc(count, sizeof(struct mfi_pd_info));
341	if (info->drives == NULL) {
342		warnx("malloc failed");
343		return (ENOMEM);
344	}
345	info->drive_count = count;
346	for (pinfo = info->drives; (cp = strsep(&array_str, ",")) != NULL;
347	     pinfo++) {
348		error = mfi_lookup_drive(fd, cp, &device_id);
349		if (error) {
350			free(info->drives);
351			return (error);
352		}
353
354		if (mfi_pd_get_info(fd, device_id, pinfo, NULL) < 0) {
355			error = errno;
356			warn("Failed to fetch drive info for drive %s", cp);
357			free(info->drives);
358			return (error);
359		}
360
361		if (pinfo->fw_state != MFI_PD_STATE_UNCONFIGURED_GOOD) {
362			warnx("Drive %u is not available", device_id);
363			free(info->drives);
364			return (EINVAL);
365		}
366	}
367
368	return (0);
369}
370
371/*
372 * Find the next free array ref assuming that 'array_ref' is the last
373 * one used.  'array_ref' should be 0xffff for the initial test.
374 */
375static uint16_t
376find_next_array(struct config_id_state *state)
377{
378	int i;
379
380	/* Assume the current one is used. */
381	state->array_ref++;
382
383	/* Find the next free one. */
384	for (i = 0; i < state->array_count; i++)
385		if (state->arrays[i] == state->array_ref)
386			state->array_ref++;
387	return (state->array_ref);
388}
389
390/*
391 * Find the next free volume ID assuming that 'target_id' is the last
392 * one used.  'target_id' should be 0xff for the initial test.
393 */
394static uint8_t
395find_next_volume(struct config_id_state *state)
396{
397	int i;
398
399	/* Assume the current one is used. */
400	state->target_id++;
401
402	/* Find the next free one. */
403	for (i = 0; i < state->log_drv_count; i++)
404		if (state->volumes[i] == state->target_id)
405			state->target_id++;
406	return (state->target_id);
407}
408
409/* Populate an array with drives. */
410static void
411build_array(int fd, char *arrayp, struct array_info *array_info,
412    struct config_id_state *state, int verbose)
413{
414	struct mfi_array *ar = (struct mfi_array *)arrayp;
415	int i;
416
417	ar->size = array_info->drives[0].coerced_size;
418	ar->num_drives = array_info->drive_count;
419	ar->array_ref = find_next_array(state);
420	for (i = 0; i < array_info->drive_count; i++) {
421		if (verbose)
422			printf("Adding drive %u to array %u\n",
423			    array_info->drives[i].ref.v.device_id,
424			    ar->array_ref);
425		if (ar->size > array_info->drives[i].coerced_size)
426			ar->size = array_info->drives[i].coerced_size;
427		ar->pd[i].ref = array_info->drives[i].ref;
428		ar->pd[i].fw_state = MFI_PD_STATE_ONLINE;
429	}
430	array_info->array = ar;
431}
432
433/*
434 * Create a volume that spans one or more arrays.
435 */
436static void
437build_volume(char *volumep, int narrays, struct array_info *arrays,
438    int raid_type, long stripe_size, struct config_id_state *state, int verbose)
439{
440	struct mfi_ld_config *ld = (struct mfi_ld_config *)volumep;
441	struct mfi_array *ar;
442	int i;
443
444	/* properties */
445	ld->properties.ld.v.target_id = find_next_volume(state);
446	ld->properties.ld.v.seq = 0;
447	ld->properties.default_cache_policy = MR_LD_CACHE_ALLOW_WRITE_CACHE |
448	    MR_LD_CACHE_WRITE_BACK;
449	ld->properties.access_policy = MFI_LD_ACCESS_RW;
450	ld->properties.disk_cache_policy = MR_PD_CACHE_UNCHANGED;
451	ld->properties.current_cache_policy = MR_LD_CACHE_ALLOW_WRITE_CACHE |
452	    MR_LD_CACHE_WRITE_BACK;
453	ld->properties.no_bgi = 0;
454
455	/* params */
456	switch (raid_type) {
457	case RT_RAID0:
458	case RT_JBOD:
459		ld->params.primary_raid_level = DDF_RAID0;
460		ld->params.raid_level_qualifier = 0;
461		ld->params.secondary_raid_level = 0;
462		break;
463	case RT_RAID1:
464		ld->params.primary_raid_level = DDF_RAID1;
465		ld->params.raid_level_qualifier = 0;
466		ld->params.secondary_raid_level = 0;
467		break;
468	case RT_RAID5:
469		ld->params.primary_raid_level = DDF_RAID5;
470		ld->params.raid_level_qualifier = 3;
471		ld->params.secondary_raid_level = 0;
472		break;
473	case RT_RAID6:
474		ld->params.primary_raid_level = DDF_RAID6;
475		ld->params.raid_level_qualifier = 3;
476		ld->params.secondary_raid_level = 0;
477		break;
478	case RT_CONCAT:
479		ld->params.primary_raid_level = DDF_CONCAT;
480		ld->params.raid_level_qualifier = 0;
481		ld->params.secondary_raid_level = 0;
482		break;
483	case RT_RAID10:
484		ld->params.primary_raid_level = DDF_RAID1;
485		ld->params.raid_level_qualifier = 0;
486		ld->params.secondary_raid_level = 3; /* XXX? */
487		break;
488	case RT_RAID50:
489		/*
490		 * XXX: This appears to work though the card's BIOS
491		 * complains that the configuration is foreign.  The
492		 * BIOS setup does not allow for creation of RAID-50
493		 * or RAID-60 arrays.  The only nested array
494		 * configuration it allows for is RAID-10.
495		 */
496		ld->params.primary_raid_level = DDF_RAID5;
497		ld->params.raid_level_qualifier = 3;
498		ld->params.secondary_raid_level = 3; /* XXX? */
499		break;
500	case RT_RAID60:
501		ld->params.primary_raid_level = DDF_RAID6;
502		ld->params.raid_level_qualifier = 3;
503		ld->params.secondary_raid_level = 3; /* XXX? */
504		break;
505	}
506
507	/*
508	 * Stripe size is encoded as (2 ^ N) * 512 = stripe_size.  Use
509	 * ffs() to simulate log2(stripe_size).
510	 */
511	ld->params.stripe_size = ffs(stripe_size) - 1 - 9;
512	ld->params.num_drives = arrays[0].array->num_drives;
513	ld->params.span_depth = narrays;
514	ld->params.state = MFI_LD_STATE_OPTIMAL;
515	ld->params.init_state = MFI_LD_PARAMS_INIT_NO;
516	ld->params.is_consistent = 0;
517
518	/* spans */
519	for (i = 0; i < narrays; i++) {
520		ar = arrays[i].array;
521		if (verbose)
522			printf("Adding array %u to volume %u\n", ar->array_ref,
523			    ld->properties.ld.v.target_id);
524		ld->span[i].start_block = 0;
525		ld->span[i].num_blocks = ar->size;
526		ld->span[i].array_ref = ar->array_ref;
527	}
528}
529
530static int
531create_volume(int ac, char **av)
532{
533	struct mfi_config_data *config;
534	struct mfi_array *ar;
535	struct mfi_ld_config *ld;
536	struct config_id_state state;
537	size_t config_size;
538	char *p, *cfg_arrays, *cfg_volumes;
539	int error, fd, i, raid_type;
540	int narrays, nvolumes, arrays_per_volume;
541	struct array_info *arrays;
542	long stripe_size;
543#ifdef DEBUG
544	int dump;
545#endif
546	int ch, verbose;
547
548	/*
549	 * Backwards compat.  Map 'create volume' to 'create' and
550	 * 'create spare' to 'add'.
551	 */
552	if (ac > 1) {
553		if (strcmp(av[1], "volume") == 0) {
554			av++;
555			ac--;
556		} else if (strcmp(av[1], "spare") == 0) {
557			av++;
558			ac--;
559			return (add_spare(ac, av));
560		}
561	}
562
563	if (ac < 2) {
564		warnx("create volume: volume type required");
565		return (EINVAL);
566	}
567
568	bzero(&state, sizeof(state));
569	config = NULL;
570	arrays = NULL;
571	narrays = 0;
572	error = 0;
573
574	fd = mfi_open(mfi_unit);
575	if (fd < 0) {
576		error = errno;
577		warn("mfi_open");
578		return (error);
579	}
580
581	if (!mfi_reconfig_supported()) {
582		warnx("The current mfi(4) driver does not support "
583		    "configuration changes.");
584		error = EOPNOTSUPP;
585		goto error;
586	}
587
588	/* Lookup the RAID type first. */
589	raid_type = -1;
590	for (i = 0; raid_type_table[i].name != NULL; i++)
591		if (strcasecmp(raid_type_table[i].name, av[1]) == 0) {
592			raid_type = raid_type_table[i].raid_type;
593			break;
594		}
595
596	if (raid_type == -1) {
597		warnx("Unknown or unsupported volume type %s", av[1]);
598		error = EINVAL;
599		goto error;
600	}
601
602	/* Parse any options. */
603	optind = 2;
604#ifdef DEBUG
605	dump = 0;
606#endif
607	verbose = 0;
608	stripe_size = 64 * 1024;
609
610	while ((ch = getopt(ac, av, "ds:v")) != -1) {
611		switch (ch) {
612#ifdef DEBUG
613		case 'd':
614			dump = 1;
615			break;
616#endif
617		case 's':
618			stripe_size = dehumanize(optarg);
619			if ((stripe_size < 512) || (!powerof2(stripe_size)))
620				stripe_size = 64 * 1024;
621			break;
622		case 'v':
623			verbose = 1;
624			break;
625		case '?':
626		default:
627			error = EINVAL;
628			goto error;
629		}
630	}
631	ac -= optind;
632	av += optind;
633
634	/* Parse all the arrays. */
635	narrays = ac;
636	if (narrays == 0) {
637		warnx("At least one drive list is required");
638		error = EINVAL;
639		goto error;
640	}
641	switch (raid_type) {
642	case RT_RAID0:
643	case RT_RAID1:
644	case RT_RAID5:
645	case RT_RAID6:
646	case RT_CONCAT:
647		if (narrays != 1) {
648			warnx("Only one drive list can be specified");
649			error = EINVAL;
650			goto error;
651		}
652		break;
653	case RT_RAID10:
654	case RT_RAID50:
655	case RT_RAID60:
656		if (narrays < 1) {
657			warnx("RAID10, RAID50, and RAID60 require at least "
658			    "two drive lists");
659			error = EINVAL;
660			goto error;
661		}
662		if (narrays > MFI_MAX_SPAN_DEPTH) {
663			warnx("Volume spans more than %d arrays",
664			    MFI_MAX_SPAN_DEPTH);
665			error = EINVAL;
666			goto error;
667		}
668		break;
669	}
670	arrays = calloc(narrays, sizeof(*arrays));
671	if (arrays == NULL) {
672		warnx("malloc failed");
673		error = ENOMEM;
674		goto error;
675	}
676	for (i = 0; i < narrays; i++) {
677		error = parse_array(fd, raid_type, av[i], &arrays[i]);
678		if (error)
679			goto error;
680	}
681
682	switch (raid_type) {
683	case RT_RAID10:
684	case RT_RAID50:
685	case RT_RAID60:
686		for (i = 1; i < narrays; i++) {
687			if (arrays[i].drive_count != arrays[0].drive_count) {
688				warnx("All arrays must contain the same "
689				    "number of drives");
690				error = EINVAL;
691				goto error;
692			}
693		}
694		break;
695	}
696
697	/*
698	 * Fetch the current config and build sorted lists of existing
699	 * array and volume identifiers.
700	 */
701	if (mfi_config_read(fd, &config) < 0) {
702		error = errno;
703		warn("Failed to read configuration");
704		goto error;
705	}
706	p = (char *)config->array;
707	state.array_ref = 0xffff;
708	state.target_id = 0xff;
709	state.array_count = config->array_count;
710	if (config->array_count > 0) {
711		state.arrays = calloc(config->array_count, sizeof(int));
712		if (state.arrays == NULL) {
713			warnx("malloc failed");
714			error = ENOMEM;
715			goto error;
716		}
717		for (i = 0; i < config->array_count; i++) {
718			ar = (struct mfi_array *)p;
719			state.arrays[i] = ar->array_ref;
720			p += config->array_size;
721		}
722		qsort(state.arrays, config->array_count, sizeof(int),
723		    compare_int);
724	} else
725		state.arrays = NULL;
726	state.log_drv_count = config->log_drv_count;
727	if (config->log_drv_count) {
728		state.volumes = calloc(config->log_drv_count, sizeof(int));
729		if (state.volumes == NULL) {
730			warnx("malloc failed");
731			error = ENOMEM;
732			goto error;
733		}
734		for (i = 0; i < config->log_drv_count; i++) {
735			ld = (struct mfi_ld_config *)p;
736			state.volumes[i] = ld->properties.ld.v.target_id;
737			p += config->log_drv_size;
738		}
739		qsort(state.volumes, config->log_drv_count, sizeof(int),
740		    compare_int);
741	} else
742		state.volumes = NULL;
743	free(config);
744
745	/* Determine the size of the configuration we will build. */
746	switch (raid_type) {
747	case RT_RAID0:
748	case RT_RAID1:
749	case RT_RAID5:
750	case RT_RAID6:
751	case RT_CONCAT:
752	case RT_JBOD:
753		/* Each volume spans a single array. */
754		nvolumes = narrays;
755		break;
756	case RT_RAID10:
757	case RT_RAID50:
758	case RT_RAID60:
759		/* A single volume spans multiple arrays. */
760		nvolumes = 1;
761		break;
762	default:
763		/* Pacify gcc. */
764		abort();
765	}
766
767	config_size = sizeof(struct mfi_config_data) +
768	    sizeof(struct mfi_ld_config) * nvolumes + MFI_ARRAY_SIZE * narrays;
769	config = calloc(1, config_size);
770	if (config == NULL) {
771		warnx("malloc failed");
772		error = ENOMEM;
773		goto error;
774	}
775	config->size = config_size;
776	config->array_count = narrays;
777	config->array_size = MFI_ARRAY_SIZE;	/* XXX: Firmware hardcode */
778	config->log_drv_count = nvolumes;
779	config->log_drv_size = sizeof(struct mfi_ld_config);
780	config->spares_count = 0;
781	config->spares_size = 40;		/* XXX: Firmware hardcode */
782	cfg_arrays = (char *)config->array;
783	cfg_volumes = cfg_arrays + config->array_size * narrays;
784
785	/* Build the arrays. */
786	for (i = 0; i < narrays; i++) {
787		build_array(fd, cfg_arrays, &arrays[i], &state, verbose);
788		cfg_arrays += config->array_size;
789	}
790
791	/* Now build the volume(s). */
792	arrays_per_volume = narrays / nvolumes;
793	for (i = 0; i < nvolumes; i++) {
794		build_volume(cfg_volumes, arrays_per_volume,
795		    &arrays[i * arrays_per_volume], raid_type, stripe_size,
796		    &state, verbose);
797		cfg_volumes += config->log_drv_size;
798	}
799
800#ifdef DEBUG
801	if (dump)
802		dump_config(fd, config);
803#endif
804
805	/* Send the new config to the controller. */
806	if (mfi_dcmd_command(fd, MFI_DCMD_CFG_ADD, config, config_size,
807	    NULL, 0, NULL) < 0) {
808		error = errno;
809		warn("Failed to add volume");
810		/* FALLTHROUGH */
811	}
812
813error:
814	/* Clean up. */
815	free(config);
816	free(state.volumes);
817	free(state.arrays);
818	for (i = 0; i < narrays; i++)
819		free(arrays[i].drives);
820	free(arrays);
821	close(fd);
822
823	return (error);
824}
825MFI_COMMAND(top, create, create_volume);
826
827static int
828delete_volume(int ac, char **av)
829{
830	struct mfi_ld_info info;
831	int error, fd;
832	uint8_t target_id, mbox[4];
833
834	/*
835	 * Backwards compat.  Map 'delete volume' to 'delete' and
836	 * 'delete spare' to 'remove'.
837	 */
838	if (ac > 1) {
839		if (strcmp(av[1], "volume") == 0) {
840			av++;
841			ac--;
842		} else if (strcmp(av[1], "spare") == 0) {
843			av++;
844			ac--;
845			return (remove_spare(ac, av));
846		}
847	}
848
849	if (ac != 2) {
850		warnx("delete volume: volume required");
851		return (EINVAL);
852	}
853
854	fd = mfi_open(mfi_unit);
855	if (fd < 0) {
856		error = errno;
857		warn("mfi_open");
858		return (error);
859	}
860
861	if (!mfi_reconfig_supported()) {
862		warnx("The current mfi(4) driver does not support "
863		    "configuration changes.");
864		close(fd);
865		return (EOPNOTSUPP);
866	}
867
868	if (mfi_lookup_volume(fd, av[1], &target_id) < 0) {
869		error = errno;
870		warn("Invalid volume %s", av[1]);
871		close(fd);
872		return (error);
873	}
874
875	if (mfi_ld_get_info(fd, target_id, &info, NULL) < 0) {
876		error = errno;
877		warn("Failed to get info for volume %d", target_id);
878		close(fd);
879		return (error);
880	}
881
882	if (mfi_volume_busy(fd, target_id)) {
883		warnx("Volume %s is busy and cannot be deleted",
884		    mfi_volume_name(fd, target_id));
885		close(fd);
886		return (EBUSY);
887	}
888
889	mbox_store_ldref(mbox, &info.ld_config.properties.ld);
890	if (mfi_dcmd_command(fd, MFI_DCMD_LD_DELETE, NULL, 0, mbox,
891	    sizeof(mbox), NULL) < 0) {
892		error = errno;
893		warn("Failed to delete volume");
894		close(fd);
895		return (error);
896	}
897
898	close(fd);
899
900	return (0);
901}
902MFI_COMMAND(top, delete, delete_volume);
903
904static int
905add_spare(int ac, char **av)
906{
907	struct mfi_pd_info info;
908	struct mfi_config_data *config;
909	struct mfi_array *ar;
910	struct mfi_ld_config *ld;
911	struct mfi_spare *spare;
912	uint16_t device_id;
913	uint8_t target_id;
914	char *p;
915	int error, fd, i;
916
917	if (ac < 2) {
918		warnx("add spare: drive required");
919		return (EINVAL);
920	}
921
922	fd = mfi_open(mfi_unit);
923	if (fd < 0) {
924		error = errno;
925		warn("mfi_open");
926		return (error);
927	}
928
929	config = NULL;
930	spare = NULL;
931	error = mfi_lookup_drive(fd, av[1], &device_id);
932	if (error)
933		goto error;
934
935	if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) {
936		error = errno;
937		warn("Failed to fetch drive info");
938		goto error;
939	}
940
941	if (info.fw_state != MFI_PD_STATE_UNCONFIGURED_GOOD) {
942		warnx("Drive %u is not available", device_id);
943		error = EINVAL;
944		goto error;
945	}
946
947	if (ac > 2) {
948		if (mfi_lookup_volume(fd, av[2], &target_id) < 0) {
949			error = errno;
950			warn("Invalid volume %s", av[2]);
951			goto error;
952		}
953	}
954
955	if (mfi_config_read(fd, &config) < 0) {
956		error = errno;
957		warn("Failed to read configuration");
958		goto error;
959	}
960
961	spare = malloc(sizeof(struct mfi_spare) + sizeof(uint16_t) *
962	    config->array_count);
963	if (spare == NULL) {
964		warnx("malloc failed");
965		error = ENOMEM;
966		goto error;
967	}
968	bzero(spare, sizeof(struct mfi_spare));
969	spare->ref = info.ref;
970
971	if (ac == 2) {
972		/* Global spare backs all arrays. */
973		p = (char *)config->array;
974		for (i = 0; i < config->array_count; i++) {
975			ar = (struct mfi_array *)p;
976			if (ar->size > info.coerced_size) {
977				warnx("Spare isn't large enough for array %u",
978				    ar->array_ref);
979				error = EINVAL;
980				goto error;
981			}
982			p += config->array_size;
983		}
984		spare->array_count = 0;
985	} else  {
986		/*
987		 * Dedicated spares only back the arrays for a
988		 * specific volume.
989		 */
990		ld = mfi_config_lookup_volume(config, target_id);
991		if (ld == NULL) {
992			warnx("Did not find volume %d", target_id);
993			error = EINVAL;
994			goto error;
995		}
996
997		spare->spare_type |= MFI_SPARE_DEDICATED;
998		spare->array_count = ld->params.span_depth;
999		for (i = 0; i < ld->params.span_depth; i++) {
1000			ar = mfi_config_lookup_array(config,
1001			    ld->span[i].array_ref);
1002			if (ar == NULL) {
1003				warnx("Missing array; inconsistent config?");
1004				error = ENXIO;
1005				goto error;
1006			}
1007			if (ar->size > info.coerced_size) {
1008				warnx("Spare isn't large enough for array %u",
1009				    ar->array_ref);
1010				error = EINVAL;
1011				goto error;
1012			}
1013			spare->array_ref[i] = ar->array_ref;
1014		}
1015	}
1016
1017	if (mfi_dcmd_command(fd, MFI_DCMD_CFG_MAKE_SPARE, spare,
1018	    sizeof(struct mfi_spare) + sizeof(uint16_t) * spare->array_count,
1019	    NULL, 0, NULL) < 0) {
1020		error = errno;
1021		warn("Failed to assign spare");
1022		/* FALLTHROUGH. */
1023	}
1024
1025error:
1026	free(spare);
1027	free(config);
1028	close(fd);
1029
1030	return (error);
1031}
1032MFI_COMMAND(top, add, add_spare);
1033
1034static int
1035remove_spare(int ac, char **av)
1036{
1037	struct mfi_pd_info info;
1038	int error, fd;
1039	uint16_t device_id;
1040	uint8_t mbox[4];
1041
1042	if (ac != 2) {
1043		warnx("remove spare: drive required");
1044		return (EINVAL);
1045	}
1046
1047	fd = mfi_open(mfi_unit);
1048	if (fd < 0) {
1049		error = errno;
1050		warn("mfi_open");
1051		return (error);
1052	}
1053
1054	error = mfi_lookup_drive(fd, av[1], &device_id);
1055	if (error) {
1056		close(fd);
1057		return (error);
1058	}
1059
1060	/* Get the info for this drive. */
1061	if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) {
1062		error = errno;
1063		warn("Failed to fetch info for drive %u", device_id);
1064		close(fd);
1065		return (error);
1066	}
1067
1068	if (info.fw_state != MFI_PD_STATE_HOT_SPARE) {
1069		warnx("Drive %u is not a hot spare", device_id);
1070		close(fd);
1071		return (EINVAL);
1072	}
1073
1074	mbox_store_pdref(mbox, &info.ref);
1075	if (mfi_dcmd_command(fd, MFI_DCMD_CFG_REMOVE_SPARE, NULL, 0, mbox,
1076	    sizeof(mbox), NULL) < 0) {
1077		error = errno;
1078		warn("Failed to delete spare");
1079		close(fd);
1080		return (error);
1081	}
1082
1083	close(fd);
1084
1085	return (0);
1086}
1087MFI_COMMAND(top, remove, remove_spare);
1088
1089#ifdef DEBUG
1090/* Display raw data about a config. */
1091static void
1092dump_config(int fd, struct mfi_config_data *config)
1093{
1094	struct mfi_array *ar;
1095	struct mfi_ld_config *ld;
1096	struct mfi_spare *sp;
1097	struct mfi_pd_info pinfo;
1098	uint16_t device_id;
1099	char *p;
1100	int i, j;
1101
1102	printf(
1103	    "mfi%d Configuration (Debug): %d arrays, %d volumes, %d spares\n",
1104	    mfi_unit, config->array_count, config->log_drv_count,
1105	    config->spares_count);
1106	printf("  array size: %u\n", config->array_size);
1107	printf("  volume size: %u\n", config->log_drv_size);
1108	printf("  spare size: %u\n", config->spares_size);
1109	p = (char *)config->array;
1110
1111	for (i = 0; i < config->array_count; i++) {
1112		ar = (struct mfi_array *)p;
1113		printf("    array %u of %u drives:\n", ar->array_ref,
1114		    ar->num_drives);
1115		printf("      size = %ju\n", (uintmax_t)ar->size);
1116		for (j = 0; j < ar->num_drives; j++) {
1117			device_id = ar->pd[j].ref.v.device_id;
1118			if (device_id == 0xffff)
1119				printf("        drive MISSING\n");
1120			else {
1121				printf("        drive %u %s\n", device_id,
1122				    mfi_pdstate(ar->pd[j].fw_state));
1123				if (mfi_pd_get_info(fd, device_id, &pinfo,
1124				    NULL) >= 0) {
1125					printf("          raw size: %ju\n",
1126					    (uintmax_t)pinfo.raw_size);
1127					printf("          non-coerced size: %ju\n",
1128					    (uintmax_t)pinfo.non_coerced_size);
1129					printf("          coerced size: %ju\n",
1130					    (uintmax_t)pinfo.coerced_size);
1131				}
1132			}
1133		}
1134		p += config->array_size;
1135	}
1136
1137	for (i = 0; i < config->log_drv_count; i++) {
1138		ld = (struct mfi_ld_config *)p;
1139		printf("    volume %s ",
1140		    mfi_volume_name(fd, ld->properties.ld.v.target_id));
1141		printf("%s %s",
1142		    mfi_raid_level(ld->params.primary_raid_level,
1143			ld->params.secondary_raid_level),
1144		    mfi_ldstate(ld->params.state));
1145		if (ld->properties.name[0] != '\0')
1146			printf(" <%s>", ld->properties.name);
1147		printf("\n");
1148		printf("      primary raid level: %u\n",
1149		    ld->params.primary_raid_level);
1150		printf("      raid level qualifier: %u\n",
1151		    ld->params.raid_level_qualifier);
1152		printf("      secondary raid level: %u\n",
1153		    ld->params.secondary_raid_level);
1154		printf("      stripe size: %u\n", ld->params.stripe_size);
1155		printf("      num drives: %u\n", ld->params.num_drives);
1156		printf("      init state: %u\n", ld->params.init_state);
1157		printf("      consistent: %u\n", ld->params.is_consistent);
1158		printf("      no bgi: %u\n", ld->properties.no_bgi);
1159		printf("      spans:\n");
1160		for (j = 0; j < ld->params.span_depth; j++) {
1161			printf("        array %u @ ", ld->span[j].array_ref);
1162			printf("%ju : %ju\n",
1163			    (uintmax_t)ld->span[j].start_block,
1164			    (uintmax_t)ld->span[j].num_blocks);
1165		}
1166		p += config->log_drv_size;
1167	}
1168
1169	for (i = 0; i < config->spares_count; i++) {
1170		sp = (struct mfi_spare *)p;
1171		printf("    %s spare %u ",
1172		    sp->spare_type & MFI_SPARE_DEDICATED ? "dedicated" :
1173		    "global", sp->ref.v.device_id);
1174		printf("%s", mfi_pdstate(MFI_PD_STATE_HOT_SPARE));
1175		printf(" backs:\n");
1176		for (j = 0; j < sp->array_count; j++)
1177			printf("        array %u\n", sp->array_ref[j]);
1178		p += config->spares_size;
1179	}
1180}
1181
1182static int
1183debug_config(int ac, char **av)
1184{
1185	struct mfi_config_data *config;
1186	int error, fd;
1187
1188	if (ac != 1) {
1189		warnx("debug: extra arguments");
1190		return (EINVAL);
1191	}
1192
1193	fd = mfi_open(mfi_unit);
1194	if (fd < 0) {
1195		error = errno;
1196		warn("mfi_open");
1197		return (error);
1198	}
1199
1200	/* Get the config from the controller. */
1201	if (mfi_config_read(fd, &config) < 0) {
1202		error = errno;
1203		warn("Failed to get config");
1204		close(fd);
1205		return (error);
1206	}
1207
1208	/* Dump out the configuration. */
1209	dump_config(fd, config);
1210	free(config);
1211	close(fd);
1212
1213	return (0);
1214}
1215MFI_COMMAND(top, debug, debug_config);
1216
1217static int
1218dump(int ac, char **av)
1219{
1220	struct mfi_config_data *config;
1221	char buf[64];
1222	size_t len;
1223	int error, fd;
1224
1225	if (ac != 1) {
1226		warnx("dump: extra arguments");
1227		return (EINVAL);
1228	}
1229
1230	fd = mfi_open(mfi_unit);
1231	if (fd < 0) {
1232		error = errno;
1233		warn("mfi_open");
1234		return (error);
1235	}
1236
1237	/* Get the stashed copy of the last dcmd from the driver. */
1238	snprintf(buf, sizeof(buf), "dev.mfi.%d.debug_command", mfi_unit);
1239	if (sysctlbyname(buf, NULL, &len, NULL, 0) < 0) {
1240		error = errno;
1241		warn("Failed to read debug command");
1242		if (error == ENOENT)
1243			error = EOPNOTSUPP;
1244		close(fd);
1245		return (error);
1246	}
1247
1248	config = malloc(len);
1249	if (config == NULL) {
1250		warnx("malloc failed");
1251		close(fd);
1252		return (ENOMEM);
1253	}
1254	if (sysctlbyname(buf, config, &len, NULL, 0) < 0) {
1255		error = errno;
1256		warn("Failed to read debug command");
1257		free(config);
1258		close(fd);
1259		return (error);
1260	}
1261	dump_config(fd, config);
1262	free(config);
1263	close(fd);
1264
1265	return (0);
1266}
1267MFI_COMMAND(top, dump, dump);
1268#endif
1269