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