raidctl.c revision 1.84 1 /* $NetBSD: raidctl.c,v 1.84 2024/11/05 19:52:18 rillig Exp $ */
2
3 /*-
4 * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Greg Oster
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * This program is a re-write of the original rf_ctrl program
34 * distributed by CMU with RAIDframe 1.1.
35 *
36 * This program is the user-land interface to the RAIDframe kernel
37 * driver in NetBSD.
38 */
39 #include <sys/cdefs.h>
40
41 #ifndef lint
42 __RCSID("$NetBSD: raidctl.c,v 1.84 2024/11/05 19:52:18 rillig Exp $");
43 #endif
44
45
46 #include <sys/param.h>
47 #include <sys/ioctl.h>
48 #include <sys/stat.h>
49 #include <sys/disklabel.h>
50
51 #include <ctype.h>
52 #include <err.h>
53 #include <errno.h>
54 #include <fcntl.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #include <inttypes.h>
59 #include <unistd.h>
60 #include <util.h>
61
62 #include <dev/raidframe/raidframevar.h>
63 #include <dev/raidframe/raidframeio.h>
64 #include "rf_configure.h"
65 #include "prog_ops.h"
66
67 #ifndef RAIDFRAME_REMOVE_COMPONENT
68 #define RAIDFRAME_REMOVE_COMPONENT RAIDFRAME_REMOVE_HOT_SPARE
69 #endif
70
71 #define CONFIGURE_TEST 1 /* must be different from any raidframe ioctl */
72
73 void do_ioctl(int, u_long, void *, const char *);
74 static void rf_configure(int, char*, int);
75 static const char *device_status(RF_DiskStatus_t);
76 static void rf_get_device_status(int);
77 static void rf_output_configuration(int, const char *);
78 static void get_component_number(int, char *, int *, int *);
79 static void rf_fail_disk(int, char *, int);
80 __dead static void usage(void);
81 static void get_component_label(int, char *);
82 static void set_component_label(int, char *);
83 static void init_component_labels(int, int);
84 static void set_autoconfig(int, int, char *);
85 static void add_hot_spare(int, char *);
86 static void remove_component(int, char *);
87 static void rebuild_in_place(int, char *);
88 static void check_status(int,int);
89 static void check_parity(int,int, char *);
90 static void do_meter(int, u_long);
91 static void get_bar(char *, double, int);
92 static void get_time_string(char *, size_t, int);
93 static void rf_output_pmstat(int, int);
94 static void rf_pm_configure(int, int, char *, int[]);
95 static void rf_simple_create(int, int, char *[]);
96 static unsigned int xstrtouint(const char *);
97
98 int verbose;
99
100 static const char *rootpart[] = { "No", "Force", "Soft", "*invalid*" };
101
102 static void
103 get_comp(char *buf, char *arg, size_t bufsz)
104 {
105 if (getfsspecname(buf, bufsz, arg) == NULL)
106 errx(1,"%s",buf);
107 }
108
109 int
110 main(int argc,char *argv[])
111 {
112 int ch, i;
113 int num_options;
114 unsigned long action;
115 char config_filename[PATH_MAX];
116 char dev_name[PATH_MAX];
117 char name[PATH_MAX];
118 char component[PATH_MAX];
119 char autoconf[10];
120 char *parityconf = NULL;
121 int parityparams[3];
122 int do_output;
123 int do_recon;
124 int do_rewrite;
125 int raidID;
126 int serial_number;
127 struct stat st;
128 int fd;
129 int force;
130 int openmode;
131 int last_unit;
132 struct timeval tv;
133
134 num_options = 0;
135 action = 0;
136 do_output = 0;
137 do_recon = 0;
138 do_rewrite = 0;
139 serial_number = 0;
140 force = 0;
141 last_unit = 0;
142 openmode = O_RDWR; /* default to read/write */
143
144 if (argc > 5) {
145 /* we have at least 5 args, so it might be a simplified config */
146
147 strlcpy(name, argv[1], sizeof(name));
148 fd = opendisk(name, openmode, dev_name, sizeof(dev_name), 0);
149 if (fd != -1) {
150 /* we were able to open the device... */
151 if (fstat(fd, &st) == -1)
152 err(1, "stat failure on: %s", dev_name);
153 if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
154 err(1, "invalid device: %s", dev_name);
155
156 raidID = DISKUNIT(st.st_rdev);
157 if (strncmp(argv[2],"create",6)==0) {
158 rf_simple_create(fd,argc-3,&argv[3]);
159
160 /* set serial number, set autoconfig, init parity */
161
162 if (gettimeofday(&tv,NULL) == -1) {
163 serial_number = 12345777;
164 } else {
165 serial_number = tv.tv_sec;
166 }
167 init_component_labels(fd, serial_number);
168 strlcpy(autoconf, "yes", sizeof(autoconf));
169 set_autoconfig(fd, raidID, autoconf);
170
171 } else
172 usage();
173
174 close(fd);
175 exit(0);
176 }
177
178 /* otherwise we go back to regular parsing */
179 }
180
181 while ((ch = getopt(argc, argv,
182 "a:A:c:C:f:F:g:GiI:l:LmM:r:R:sSpPt:uU:v")) != -1)
183 switch (ch) {
184 case 'a':
185 action = RAIDFRAME_ADD_HOT_SPARE;
186 get_comp(component, optarg, sizeof(component));
187 num_options++;
188 break;
189 case 'A':
190 action = RAIDFRAME_SET_AUTOCONFIG;
191 strlcpy(autoconf, optarg, sizeof(autoconf));
192 num_options++;
193 break;
194 case 'c':
195 action = RAIDFRAME_CONFIGURE;
196 strlcpy(config_filename, optarg,
197 sizeof(config_filename));
198 force = 0;
199 num_options++;
200 break;
201 case 'C':
202 strlcpy(config_filename, optarg,
203 sizeof(config_filename));
204 action = RAIDFRAME_CONFIGURE;
205 force = 1;
206 num_options++;
207 break;
208 case 'f':
209 action = RAIDFRAME_FAIL_DISK;
210 get_comp(component, optarg, sizeof(component));
211 do_recon = 0;
212 num_options++;
213 break;
214 case 'F':
215 action = RAIDFRAME_FAIL_DISK;
216 get_comp(component, optarg, sizeof(component));
217 do_recon = 1;
218 num_options++;
219 break;
220 case 'g':
221 action = RAIDFRAME_GET_COMPONENT_LABEL;
222 get_comp(component, optarg, sizeof(component));
223 openmode = O_RDONLY;
224 num_options++;
225 break;
226 case 'G':
227 action = RAIDFRAME_GET_INFO;
228 openmode = O_RDONLY;
229 do_output = 1;
230 num_options++;
231 break;
232 case 'i':
233 action = RAIDFRAME_REWRITEPARITY;
234 num_options++;
235 break;
236 case 'I':
237 action = RAIDFRAME_INIT_LABELS;
238 serial_number = xstrtouint(optarg);
239 num_options++;
240 break;
241 case 'l':
242 action = RAIDFRAME_SET_COMPONENT_LABEL;
243 get_comp(component, optarg, sizeof(component));
244 num_options++;
245 break;
246 case 'L':
247 action = RAIDFRAME_RESCAN;
248 num_options++;
249 break;
250 case 'm':
251 action = RAIDFRAME_PARITYMAP_STATUS;
252 openmode = O_RDONLY;
253 num_options++;
254 break;
255 case 'M':
256 action = RAIDFRAME_PARITYMAP_SET_DISABLE;
257 parityconf = strdup(optarg);
258 num_options++;
259 /* XXXjld: should rf_pm_configure do the strtol()s? */
260 i = 0;
261 while (i < 3 && optind < argc &&
262 isdigit((int)argv[optind][0]))
263 parityparams[i++] = xstrtouint(argv[optind++]);
264 while (i < 3)
265 parityparams[i++] = 0;
266 break;
267 case 'p':
268 action = RAIDFRAME_CHECK_PARITY;
269 openmode = O_RDONLY;
270 num_options++;
271 break;
272 case 'P':
273 action = RAIDFRAME_CHECK_PARITY;
274 do_rewrite = 1;
275 num_options++;
276 break;
277 case 'r':
278 action = RAIDFRAME_REMOVE_COMPONENT;
279 get_comp(component, optarg, sizeof(component));
280 num_options++;
281 break;
282 case 'R':
283 get_comp(component, optarg, sizeof(component));
284 action = RAIDFRAME_REBUILD_IN_PLACE;
285 num_options++;
286 break;
287 case 's':
288 action = RAIDFRAME_GET_INFO;
289 openmode = O_RDONLY;
290 num_options++;
291 break;
292 case 'S':
293 action = RAIDFRAME_CHECK_RECON_STATUS_EXT;
294 openmode = O_RDONLY;
295 num_options++;
296 break;
297 case 't':
298 action = CONFIGURE_TEST;
299 strlcpy(config_filename, optarg,
300 sizeof(config_filename));
301 num_options++;
302 break;
303 case 'u':
304 action = RAIDFRAME_SHUTDOWN;
305 num_options++;
306 break;
307 case 'U':
308 action = RAIDFRAME_SET_LAST_UNIT;
309 num_options++;
310 last_unit = atoi(optarg);
311 if (last_unit < 0)
312 errx(1, "Bad last unit %s", optarg);
313 break;
314 case 'v':
315 verbose = 1;
316 /* Don't bump num_options, as '-v' is not
317 an option like the others */
318 /* num_options++; */
319 break;
320 default:
321 usage();
322 }
323 argc -= optind;
324 argv += optind;
325
326 if (num_options > 1)
327 usage();
328
329 if (action == CONFIGURE_TEST) {
330 RF_Config_t cfg;
331
332 if (argc != 0)
333 usage();
334 if (rf_MakeConfig(config_filename, &cfg) != 0)
335 exit(1);
336 exit(0);;
337 }
338
339 if (argc != 1)
340 usage();
341
342 if (prog_init && prog_init() == -1)
343 err(1, "init failed");
344
345 strlcpy(name, argv[0], sizeof(name));
346 fd = opendisk1(name, openmode, dev_name, sizeof(dev_name), 0,
347 prog_open);
348 if (fd == -1)
349 err(1, "Unable to open device file: %s", name);
350 if (prog_fstat(fd, &st) == -1)
351 err(1, "stat failure on: %s", dev_name);
352 if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
353 err(1, "invalid device: %s", dev_name);
354
355 raidID = DISKUNIT(st.st_rdev);
356
357 switch (action) {
358 case RAIDFRAME_ADD_HOT_SPARE:
359 add_hot_spare(fd, component);
360 break;
361 case RAIDFRAME_REMOVE_COMPONENT:
362 remove_component(fd, component);
363 break;
364 case RAIDFRAME_CONFIGURE:
365 rf_configure(fd, config_filename, force);
366 break;
367 case RAIDFRAME_SET_AUTOCONFIG:
368 set_autoconfig(fd, raidID, autoconf);
369 break;
370 case RAIDFRAME_FAIL_DISK:
371 rf_fail_disk(fd, component, do_recon);
372 break;
373 case RAIDFRAME_SET_COMPONENT_LABEL:
374 set_component_label(fd, component);
375 break;
376 case RAIDFRAME_GET_COMPONENT_LABEL:
377 get_component_label(fd, component);
378 break;
379 case RAIDFRAME_INIT_LABELS:
380 init_component_labels(fd, serial_number);
381 break;
382 case RAIDFRAME_REWRITEPARITY:
383 printf("Initiating re-write of parity\n");
384 do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
385 "RAIDFRAME_REWRITEPARITY");
386 if (verbose) {
387 sleep(3); /* XXX give it time to get started */
388 printf("Parity Re-write status:\n");
389 do_meter(fd, RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
390 }
391 break;
392 case RAIDFRAME_CHECK_RECON_STATUS_EXT:
393 check_status(fd,1);
394 break;
395 case RAIDFRAME_GET_INFO:
396 if (do_output)
397 rf_output_configuration(fd, dev_name);
398 else
399 rf_get_device_status(fd);
400 break;
401 case RAIDFRAME_PARITYMAP_STATUS:
402 rf_output_pmstat(fd, raidID);
403 break;
404 case RAIDFRAME_PARITYMAP_SET_DISABLE:
405 rf_pm_configure(fd, raidID, parityconf, parityparams);
406 break;
407 case RAIDFRAME_REBUILD_IN_PLACE:
408 rebuild_in_place(fd, component);
409 break;
410 case RAIDFRAME_CHECK_PARITY:
411 check_parity(fd, do_rewrite, dev_name);
412 break;
413 case RAIDFRAME_SHUTDOWN:
414 do_ioctl(fd, RAIDFRAME_SHUTDOWN, NULL, "RAIDFRAME_SHUTDOWN");
415 break;
416 case RAIDFRAME_SET_LAST_UNIT:
417 do_ioctl(fd, RAIDFRAME_SET_LAST_UNIT, &last_unit,
418 "RAIDFRAME_SET_LAST_UNIT");
419 break;
420 case RAIDFRAME_RESCAN:
421 do_ioctl(fd, RAIDFRAME_RESCAN, NULL, "RAIDFRAME_RESCAN");
422 break;
423 default:
424 break;
425 }
426
427 prog_close(fd);
428 exit(0);
429 }
430
431 void
432 do_ioctl(int fd, unsigned long command, void *arg, const char *ioctl_name)
433 {
434 if (prog_ioctl(fd, command, arg) == -1)
435 err(1, "ioctl (%s) failed", ioctl_name);
436 }
437
438
439 static void
440 rf_configure(int fd, char *config_file, int force)
441 {
442 void *generic;
443 RF_Config_t cfg;
444
445 if (rf_MakeConfig( config_file, &cfg ) != 0)
446 err(1, "Unable to create RAIDframe configuration structure");
447
448 cfg.force = force;
449
450 /*
451 * Note the extra level of redirection needed here, since
452 * what we really want to pass in is a pointer to the pointer to
453 * the configuration structure.
454 */
455
456 generic = &cfg;
457 do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");
458 }
459
460 static const char *
461 device_status(RF_DiskStatus_t status)
462 {
463
464 switch (status) {
465 case rf_ds_optimal:
466 return ("optimal");
467 break;
468 case rf_ds_failed:
469 return ("failed");
470 break;
471 case rf_ds_reconstructing:
472 return ("reconstructing");
473 break;
474 case rf_ds_dist_spared:
475 return ("dist_spared");
476 break;
477 case rf_ds_spared:
478 return ("spared");
479 break;
480 case rf_ds_spare:
481 return ("spare");
482 break;
483 case rf_ds_used_spare:
484 return ("used_spare");
485 break;
486 default:
487 return ("UNKNOWN");
488 }
489 /* NOTREACHED */
490 }
491
492 static void
493 rf_get_device_status(int fd)
494 {
495 RF_DeviceConfig_t device_config;
496 void *cfg_ptr;
497 int is_clean;
498 int i, nspares;
499
500 cfg_ptr = &device_config;
501
502 do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr, "RAIDFRAME_GET_INFO");
503
504 printf("Components:\n");
505 for(i=0; i < device_config.ndevs; i++) {
506 printf("%20s: %s\n", device_config.devs[i].devname,
507 device_status(device_config.devs[i].status));
508 }
509
510 nspares = MIN(device_config.nspares,
511 __arraycount(device_config.spares));
512
513 if (nspares > 0) {
514 printf("Spares:\n");
515 for(i=0; i < nspares; i++) {
516 printf("%20s: %s\n",
517 device_config.spares[i].devname,
518 device_status(device_config.spares[i].status));
519 }
520 } else {
521 printf("No spares.\n");
522 }
523 for(i=0; i < device_config.ndevs; i++) {
524 if (device_config.devs[i].status == rf_ds_optimal) {
525 get_component_label(fd, device_config.devs[i].devname);
526 } else {
527 printf("%s status is: %s. Skipping label.\n",
528 device_config.devs[i].devname,
529 device_status(device_config.devs[i].status));
530 }
531 }
532
533 if (nspares > 0) {
534 for(i=0; i < nspares; i++) {
535 if ((device_config.spares[i].status ==
536 rf_ds_optimal) ||
537 (device_config.spares[i].status ==
538 rf_ds_used_spare)) {
539 get_component_label(fd,
540 device_config.spares[i].devname);
541 } else {
542 printf("%s status is: %s. Skipping label.\n",
543 device_config.spares[i].devname,
544 device_status(
545 device_config.spares[i].status));
546 }
547 }
548 }
549
550 do_ioctl(fd, RAIDFRAME_CHECK_PARITY, &is_clean,
551 "RAIDFRAME_CHECK_PARITY");
552 if (is_clean) {
553 printf("Parity status: clean\n");
554 } else {
555 printf("Parity status: DIRTY\n");
556 }
557 check_status(fd,0);
558 }
559
560 static void
561 rf_output_pmstat(int fd, int raidID)
562 {
563 char srs[7];
564 unsigned int i, j;
565 int dis, dr;
566 struct rf_pmstat st;
567
568 if (prog_ioctl(fd, RAIDFRAME_PARITYMAP_STATUS, &st) == -1) {
569 if (errno == EINVAL) {
570 printf("raid%d: has no parity; parity map disabled\n",
571 raidID);
572 return;
573 }
574 err(1, "ioctl (%s) failed", "RAIDFRAME_PARITYMAP_STATUS");
575 }
576
577 if (st.enabled) {
578 if (0 > humanize_number(srs, 7, st.region_size * DEV_BSIZE,
579 "B", HN_AUTOSCALE, HN_NOSPACE))
580 strlcpy(srs, "???", 7);
581
582 printf("raid%d: parity map enabled with %u regions of %s\n",
583 raidID, st.params.regions, srs);
584 printf("raid%d: regions marked clean after %d intervals of"
585 " %d.%03ds\n", raidID, st.params.cooldown,
586 st.params.tickms / 1000, st.params.tickms % 1000);
587 printf("raid%d: write/sync/clean counters "
588 "%"PRIu64"/%"PRIu64"/%"PRIu64"\n", raidID,
589 st.ctrs.nwrite, st.ctrs.ncachesync, st.ctrs.nclearing);
590
591 dr = 0;
592 for (i = 0; i < st.params.regions; i++)
593 if (isset(st.dirty, i))
594 dr++;
595 printf("raid%d: %d dirty region%s\n", raidID, dr,
596 dr == 1 ? "" : "s");
597
598 if (verbose > 0) {
599 for (i = 0; i < RF_PARITYMAP_NBYTE; i += 32) {
600 printf(" ");
601 for (j = i; j < RF_PARITYMAP_NBYTE
602 && j < i + 32; j++)
603 printf("%x%x", st.dirty[j] & 15,
604 (st.dirty[j] >> 4) & 15);
605 printf("\n");
606 }
607 }
608 } else {
609 printf("raid%d: parity map disabled\n", raidID);
610 }
611
612 do_ioctl(fd, RAIDFRAME_PARITYMAP_GET_DISABLE, &dis,
613 "RAIDFRAME_PARITYMAP_GET_DISABLE");
614 printf("raid%d: parity map will %s %sabled on next configure\n",
615 raidID, dis == st.enabled ? "be" : "remain", dis ? "dis" : "en");
616 }
617
618 static void
619 rf_pm_configure(int fd, int raidID, char *parityconf, int parityparams[])
620 {
621 int dis;
622 struct rf_pmparams params;
623
624 if (strcasecmp(parityconf, "yes") == 0)
625 dis = 0;
626 else if (strcasecmp(parityconf, "no") == 0)
627 dis = 1;
628 else if (strcasecmp(parityconf, "set") == 0) {
629 params.cooldown = parityparams[0];
630 params.tickms = parityparams[1];
631 params.regions = parityparams[2];
632
633 do_ioctl(fd, RAIDFRAME_PARITYMAP_SET_PARAMS, ¶ms,
634 "RAIDFRAME_PARITYMAP_SET_PARAMS");
635
636 if (params.cooldown != 0 || params.tickms != 0) {
637 printf("raid%d: parity cleaned after", raidID);
638 if (params.cooldown != 0)
639 printf(" %d", params.cooldown);
640 printf(" intervals");
641 if (params.tickms != 0) {
642 printf(" of %d.%03ds", params.tickms / 1000,
643 params.tickms % 1000);
644 }
645 printf("\n");
646 }
647 if (params.regions != 0)
648 printf("raid%d: will use %d regions on next"
649 " configuration\n", raidID, params.regions);
650
651 return;
652 /* XXX the control flow here could be prettier. */
653 } else
654 err(1, "`%s' is not a valid parity map command", parityconf);
655
656 do_ioctl(fd, RAIDFRAME_PARITYMAP_SET_DISABLE, &dis,
657 "RAIDFRAME_PARITYMAP_SET_DISABLE");
658 printf("raid%d: parity map will be %sabled on next configure\n",
659 raidID, dis ? "dis" : "en");
660 }
661
662 /* convert "component0" into "absent" */
663 static const char *rf_output_devname(const char *name)
664 {
665
666 if (strncmp(name, "component", 9) == 0)
667 return "absent";
668 return name;
669 }
670
671 static void
672 rf_output_configuration(int fd, const char *name)
673 {
674 RF_DeviceConfig_t device_config;
675 void *cfg_ptr;
676 int i, nspares;
677 RF_ComponentLabel_t component_label;
678 void *label_ptr;
679 int component_num;
680 int num_cols;
681
682 cfg_ptr = &device_config;
683
684 printf("# raidctl config file for %s\n", name);
685 printf("\n");
686 do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr, "RAIDFRAME_GET_INFO");
687
688 nspares = MIN(device_config.nspares,
689 __arraycount(device_config.spares));
690
691 printf("START array\n");
692 printf("# numCol numSpare\n");
693 printf("%d %d\n", device_config.cols, device_config.nspares);
694 printf("\n");
695
696 printf("START disks\n");
697 for(i=0; i < device_config.ndevs; i++)
698 printf("%s\n",
699 rf_output_devname(device_config.devs[i].devname));
700 printf("\n");
701
702 if (nspares > 0) {
703 printf("START spare\n");
704 for(i=0; i < nspares; i++)
705 printf("%s\n", device_config.spares[i].devname);
706 printf("\n");
707 }
708
709 for(i=0; i < device_config.ndevs; i++) {
710 if (device_config.devs[i].status == rf_ds_optimal)
711 break;
712 }
713 if (i == device_config.ndevs) {
714 printf("# WARNING: no optimal components; using %s\n",
715 device_config.devs[0].devname);
716 i = 0;
717 }
718 get_component_number(fd, device_config.devs[i].devname,
719 &component_num, &num_cols);
720 memset(&component_label, 0, sizeof(RF_ComponentLabel_t));
721 component_label.row = component_num / num_cols;
722 component_label.column = component_num % num_cols;
723 label_ptr = &component_label;
724 do_ioctl(fd, RAIDFRAME_GET_COMPONENT_LABEL, label_ptr,
725 "RAIDFRAME_GET_COMPONENT_LABEL");
726
727 printf("START layout\n");
728 printf(
729 "# sectPerSU SUsPerParityUnit SUsPerReconUnit RAID_level_%c\n",
730 (char) component_label.parityConfig);
731 printf("%d %d %d %c\n",
732 component_label.sectPerSU, component_label.SUsPerPU,
733 component_label.SUsPerRU, (char) component_label.parityConfig);
734 printf("\n");
735
736 printf("START queue\n");
737 printf("fifo %d\n", device_config.maxqdepth);
738 }
739
740 static void
741 get_component_number(int fd, char *component_name, int *component_number,
742 int *num_columns)
743 {
744 RF_DeviceConfig_t device_config;
745 void *cfg_ptr;
746 int i, nspares;
747 int found;
748
749 *component_number = -1;
750
751 /* Assuming a full path spec... */
752 cfg_ptr = &device_config;
753 do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr,
754 "RAIDFRAME_GET_INFO");
755
756 *num_columns = device_config.cols;
757
758 nspares = MIN(device_config.nspares,
759 __arraycount(device_config.spares));
760
761 found = 0;
762 for(i=0; i < device_config.ndevs; i++) {
763 if (strncmp(component_name, device_config.devs[i].devname,
764 PATH_MAX)==0) {
765 found = 1;
766 *component_number = i;
767 }
768 }
769 if (!found) { /* maybe it's a spare? */
770 for(i=0; i < nspares; i++) {
771 if (strncmp(component_name,
772 device_config.spares[i].devname,
773 PATH_MAX)==0) {
774 found = 1;
775 *component_number = i + device_config.ndevs;
776 /* the way spares are done should
777 really change... */
778 *num_columns = device_config.cols +
779 device_config.nspares;
780 }
781 }
782 }
783
784 if (!found)
785 err(1,"%s is not a component of this device", component_name);
786 }
787
788 static void
789 rf_fail_disk(int fd, char *component_to_fail, int do_recon)
790 {
791 struct rf_recon_req recon_request;
792 int component_num;
793 int num_cols;
794
795 get_component_number(fd, component_to_fail, &component_num, &num_cols);
796
797 recon_request.col = component_num % num_cols;
798 if (do_recon) {
799 recon_request.flags = RF_FDFLAGS_RECON;
800 } else {
801 recon_request.flags = RF_FDFLAGS_NONE;
802 }
803 do_ioctl(fd, RAIDFRAME_FAIL_DISK, &recon_request,
804 "RAIDFRAME_FAIL_DISK");
805 if (do_recon && verbose) {
806 printf("Reconstruction status:\n");
807 sleep(3); /* XXX give reconstruction a chance to start */
808 do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
809 }
810 }
811
812 static void
813 get_component_label(int fd, char *component)
814 {
815 RF_ComponentLabel_t component_label;
816 void *label_ptr;
817 int component_num;
818 int num_cols;
819
820 get_component_number(fd, component, &component_num, &num_cols);
821
822 memset( &component_label, 0, sizeof(RF_ComponentLabel_t));
823 component_label.row = component_num / num_cols;
824 component_label.column = component_num % num_cols;
825
826 label_ptr = &component_label;
827 do_ioctl( fd, RAIDFRAME_GET_COMPONENT_LABEL, label_ptr,
828 "RAIDFRAME_GET_COMPONENT_LABEL");
829
830 printf("Component label for %s:\n",component);
831
832 printf(" Row: %d, Column: %d, Num Rows: %d, Num Columns: %d\n",
833 component_label.row, component_label.column,
834 component_label.num_rows, component_label.num_columns);
835 printf(" Version: %d, Serial Number: %u, Mod Counter: %d\n",
836 component_label.version, component_label.serial_number,
837 component_label.mod_counter);
838 printf(" Clean: %s, Status: %d\n",
839 component_label.clean ? "Yes" : "No",
840 component_label.status );
841 printf(" sectPerSU: %d, SUsPerPU: %d, SUsPerRU: %d\n",
842 component_label.sectPerSU, component_label.SUsPerPU,
843 component_label.SUsPerRU);
844 printf(" Queue size: %d, blocksize: %d, numBlocks: %"PRIu64"\n",
845 component_label.maxOutstanding, component_label.blockSize,
846 rf_component_label_numblocks(&component_label));
847 printf(" RAID Level: %c\n", (char) component_label.parityConfig);
848 printf(" Autoconfig: %s\n",
849 component_label.autoconfigure ? "Yes" : "No" );
850 printf(" Root partition: %s\n",
851 rootpart[component_label.root_partition & 3]);
852 printf(" Last configured as: raid%d\n", component_label.last_unit );
853 }
854
855 static void
856 set_component_label(int fd, char *component)
857 {
858 RF_ComponentLabel_t component_label;
859 int component_num;
860 int num_cols;
861
862 get_component_number(fd, component, &component_num, &num_cols);
863
864 /* XXX This is currently here for testing, and future expandability */
865
866 component_label.version = 1;
867 component_label.serial_number = 123456;
868 component_label.mod_counter = 0;
869 component_label.row = component_num / num_cols;
870 component_label.column = component_num % num_cols;
871 component_label.num_rows = 0;
872 component_label.num_columns = 5;
873 component_label.clean = 0;
874 component_label.status = 1;
875
876 do_ioctl( fd, RAIDFRAME_SET_COMPONENT_LABEL, &component_label,
877 "RAIDFRAME_SET_COMPONENT_LABEL");
878 }
879
880
881 static void
882 init_component_labels(int fd, int serial_number)
883 {
884 RF_ComponentLabel_t component_label;
885
886 component_label.version = 0;
887 component_label.serial_number = serial_number;
888 component_label.mod_counter = 0;
889 component_label.row = 0;
890 component_label.column = 0;
891 component_label.num_rows = 0;
892 component_label.num_columns = 0;
893 component_label.clean = 0;
894 component_label.status = 0;
895
896 do_ioctl( fd, RAIDFRAME_INIT_LABELS, &component_label,
897 "RAIDFRAME_INIT_LABELS");
898 }
899
900 static void
901 set_autoconfig(int fd, int raidID, char *autoconf)
902 {
903 int auto_config;
904 int root_config;
905
906 auto_config = 0;
907 root_config = 0;
908
909 if (strncasecmp(autoconf, "root", 4) == 0 ||
910 strncasecmp(autoconf, "hard", 4) == 0 ||
911 strncasecmp(autoconf, "force", 5) == 0) {
912 root_config = 1;
913 } else if (strncasecmp(autoconf, "soft", 4) == 0) {
914 root_config = 2;
915 }
916
917 if ((strncasecmp(autoconf,"yes", 3) == 0) ||
918 root_config > 0) {
919 auto_config = 1;
920 }
921
922 do_ioctl(fd, RAIDFRAME_SET_AUTOCONFIG, &auto_config,
923 "RAIDFRAME_SET_AUTOCONFIG");
924
925 do_ioctl(fd, RAIDFRAME_SET_ROOT, &root_config,
926 "RAIDFRAME_SET_ROOT");
927
928 if (verbose) {
929 printf("raid%d: Autoconfigure: %s\n", raidID,
930 auto_config ? "Yes" : "No");
931 if (auto_config == 1) {
932 printf("raid%d: Root: %s\n", raidID, rootpart[root_config]);
933 }
934 }
935 }
936
937 static void
938 add_hot_spare(int fd, char *component)
939 {
940 RF_SingleComponent_t hot_spare;
941
942 hot_spare.row = 0;
943 hot_spare.column = 0;
944 strncpy(hot_spare.component_name, component,
945 sizeof(hot_spare.component_name));
946
947 do_ioctl( fd, RAIDFRAME_ADD_HOT_SPARE, &hot_spare,
948 "RAIDFRAME_ADD_HOT_SPARE");
949 }
950
951 static void
952 remove_component(int fd, char *component)
953 {
954 RF_SingleComponent_t comp;
955 int component_num;
956 int num_cols;
957
958 get_component_number(fd, component, &component_num, &num_cols);
959
960 comp.row = component_num / num_cols;
961 comp.column = component_num % num_cols;
962
963 strncpy(comp.component_name, component,
964 sizeof(comp.component_name));
965
966 do_ioctl( fd, RAIDFRAME_REMOVE_COMPONENT, &comp,
967 "RAIDFRAME_REMOVE_COMPONENT");
968 }
969
970 static void
971 rebuild_in_place(int fd, char *component)
972 {
973 RF_SingleComponent_t comp;
974 int component_num;
975 int num_cols;
976
977 get_component_number(fd, component, &component_num, &num_cols);
978
979 comp.row = 0;
980 comp.column = component_num;
981 strncpy(comp.component_name, component, sizeof(comp.component_name));
982
983 do_ioctl( fd, RAIDFRAME_REBUILD_IN_PLACE, &comp,
984 "RAIDFRAME_REBUILD_IN_PLACE");
985
986 if (verbose) {
987 printf("Reconstruction status:\n");
988 sleep(3); /* XXX give reconstruction a chance to start */
989 do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
990 }
991
992 }
993
994 static void
995 check_parity(int fd, int do_rewrite, char *dev_name)
996 {
997 int is_clean;
998 int percent_done;
999
1000 is_clean = 0;
1001 percent_done = 0;
1002 do_ioctl(fd, RAIDFRAME_CHECK_PARITY, &is_clean,
1003 "RAIDFRAME_CHECK_PARITY");
1004 if (is_clean) {
1005 printf("%s: Parity status: clean\n",dev_name);
1006 } else {
1007 printf("%s: Parity status: DIRTY\n",dev_name);
1008 if (do_rewrite) {
1009 printf("%s: Initiating re-write of parity\n",
1010 dev_name);
1011 do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
1012 "RAIDFRAME_REWRITEPARITY");
1013 sleep(3); /* XXX give it time to
1014 get started. */
1015 if (verbose) {
1016 printf("Parity Re-write status:\n");
1017 do_meter(fd,
1018 RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
1019 } else {
1020 do_ioctl(fd,
1021 RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
1022 &percent_done,
1023 "RAIDFRAME_CHECK_PARITYREWRITE_STATUS"
1024 );
1025 while( percent_done < 100 ) {
1026 sleep(3); /* wait a bit... */
1027 do_ioctl(fd,
1028 RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
1029 &percent_done,
1030 "RAIDFRAME_CHECK_PARITYREWRITE_STATUS");
1031 }
1032
1033 }
1034 printf("%s: Parity Re-write complete\n", dev_name);
1035 } else {
1036 /* parity is wrong, and is not being fixed.
1037 Exit w/ an error. */
1038 exit(1);
1039 }
1040 }
1041 }
1042
1043
1044 static void
1045 check_status(int fd, int meter)
1046 {
1047 int recon_percent_done = 0;
1048 int parity_percent_done = 0;
1049
1050 do_ioctl(fd, RAIDFRAME_CHECK_RECON_STATUS, &recon_percent_done,
1051 "RAIDFRAME_CHECK_RECON_STATUS");
1052 printf("Reconstruction is %d%% complete.\n", recon_percent_done);
1053 do_ioctl(fd, RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
1054 &parity_percent_done,
1055 "RAIDFRAME_CHECK_PARITYREWRITE_STATUS");
1056 printf("Parity Re-write is %d%% complete.\n", parity_percent_done);
1057
1058 if (meter) {
1059 /* These 3 should be mutually exclusive at this point */
1060 if (recon_percent_done < 100) {
1061 printf("Reconstruction status:\n");
1062 do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
1063 } else if (parity_percent_done < 100) {
1064 printf("Parity Re-write status:\n");
1065 do_meter(fd,RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
1066 }
1067 }
1068 }
1069
1070 const char *tbits = "|/-\\";
1071
1072 static void
1073 do_meter(int fd, u_long option)
1074 {
1075 int percent_done;
1076 RF_uint64 start_value;
1077 RF_ProgressInfo_t progressInfo;
1078 void *pInfoPtr;
1079 struct timeval start_time;
1080 struct timeval current_time;
1081 double elapsed;
1082 int elapsed_sec;
1083 int elapsed_usec;
1084 int simple_eta,last_eta;
1085 double rate;
1086 RF_uint64 amount;
1087 int tbit_value;
1088 char bar_buffer[1024];
1089 char eta_buffer[1024];
1090
1091 if (gettimeofday(&start_time,NULL) == -1)
1092 err(1, "gettimeofday failed!?!?");
1093 memset(&progressInfo, 0, sizeof(RF_ProgressInfo_t));
1094 pInfoPtr=&progressInfo;
1095
1096 percent_done = 0;
1097 do_ioctl(fd, option, pInfoPtr, "");
1098 start_value = progressInfo.completed;
1099 current_time = start_time;
1100 simple_eta = 0;
1101 last_eta = 0;
1102
1103 tbit_value = 0;
1104 while(progressInfo.completed < progressInfo.total) {
1105
1106 percent_done = (progressInfo.completed * 100) /
1107 progressInfo.total;
1108
1109 get_bar(bar_buffer, percent_done, 40);
1110
1111 elapsed_sec = current_time.tv_sec - start_time.tv_sec;
1112 elapsed_usec = current_time.tv_usec - start_time.tv_usec;
1113 if (elapsed_usec < 0) {
1114 elapsed_usec-=1000000;
1115 elapsed_sec++;
1116 }
1117
1118 elapsed = (double) elapsed_sec +
1119 (double) elapsed_usec / 1000000.0;
1120
1121 amount = progressInfo.completed - start_value;
1122
1123 if (amount <= 0) { /* we don't do negatives (yet?) */
1124 amount = 0;
1125 }
1126
1127 if (elapsed == 0)
1128 rate = 0.0;
1129 else
1130 rate = amount / elapsed;
1131
1132 if (rate > 0.0) {
1133 simple_eta = (int) (((double)progressInfo.total -
1134 (double) progressInfo.completed)
1135 / rate);
1136 } else {
1137 simple_eta = -1;
1138 }
1139
1140 if (simple_eta <=0) {
1141 simple_eta = last_eta;
1142 } else {
1143 last_eta = simple_eta;
1144 }
1145
1146 get_time_string(eta_buffer, sizeof eta_buffer, simple_eta);
1147
1148 fprintf(stdout,"\r%3d%% |%s| ETA: %s %c",
1149 percent_done,bar_buffer,eta_buffer,tbits[tbit_value]);
1150 fflush(stdout);
1151
1152 if (++tbit_value>3)
1153 tbit_value = 0;
1154
1155 sleep(2);
1156
1157 if (gettimeofday(¤t_time,NULL) == -1)
1158 err(1, "gettimeofday failed!?!?");
1159
1160 do_ioctl( fd, option, pInfoPtr, "");
1161
1162
1163 }
1164 printf("\n");
1165 }
1166 /* 40 '*''s per line, then 40 ' ''s line. */
1167 /* If you've got a screen wider than 160 characters, "tough" */
1168
1169 #define STAR_MIDPOINT 4*40
1170 const char stars[] = "****************************************"
1171 "****************************************"
1172 "****************************************"
1173 "****************************************"
1174 " "
1175 " "
1176 " "
1177 " "
1178 " ";
1179
1180 static void
1181 get_bar(char *string, double percent, int max_strlen)
1182 {
1183 int offset;
1184
1185 if (max_strlen > STAR_MIDPOINT) {
1186 max_strlen = STAR_MIDPOINT;
1187 }
1188 offset = STAR_MIDPOINT -
1189 (int)((percent * max_strlen)/ 100);
1190 if (offset < 0)
1191 offset = 0;
1192 snprintf(string,max_strlen,"%s",stars+offset);
1193 }
1194
1195 static void
1196 get_time_string(char *string, size_t len, int simple_time)
1197 {
1198 int minutes, seconds, hours;
1199 char hours_buffer[8];
1200 char minutes_buffer[5];
1201 char seconds_buffer[5];
1202
1203 if (simple_time >= 0) {
1204
1205 minutes = simple_time / 60;
1206 seconds = simple_time - 60*minutes;
1207 hours = minutes / 60;
1208 minutes = minutes - 60*hours;
1209 #if defined(__GNUC__)
1210 /*
1211 * snprintf() truncation checker fails to detect that seconds
1212 * and minutes will be 0-59 range.
1213 */
1214 if (minutes < 0 || minutes > 60)
1215 minutes = 60;
1216 if (seconds < 0 || seconds > 60)
1217 seconds = 60;
1218 #endif
1219
1220 if (hours > 0) {
1221 snprintf(hours_buffer,sizeof hours_buffer,
1222 "%02d:",hours);
1223 } else {
1224 snprintf(hours_buffer,sizeof hours_buffer," ");
1225 }
1226
1227 snprintf(minutes_buffer,sizeof minutes_buffer,"%02d:",minutes);
1228 snprintf(seconds_buffer,sizeof seconds_buffer,"%02d",seconds);
1229 snprintf(string,len,"%s%s%s",
1230 hours_buffer, minutes_buffer, seconds_buffer);
1231 } else {
1232 snprintf(string,len," --:--");
1233 }
1234
1235 }
1236
1237 /* Simplified RAID creation with a single command line... */
1238 static void
1239 rf_simple_create(int fd, int argc, char *argv[])
1240 {
1241 int i;
1242 int level;
1243 int num_components;
1244 char *components[RF_MAXCOL];
1245 void *generic;
1246 RF_Config_t cfg;
1247
1248 /*
1249 * Note the extra level of redirection needed here, since
1250 * what we really want to pass in is a pointer to the pointer to
1251 * the configuration structure.
1252 */
1253
1254
1255 if (strcmp(argv[0],"mirror")==0) {
1256 level = 1;
1257 } else
1258 level = atoi(argv[0]);
1259
1260 if (level != 0 && level != 1 && level !=5)
1261 usage();
1262
1263 /* remaining args must be components */
1264 num_components = 0;
1265 for (i=1 ; i<argc ; i++) {
1266 components[i-1] = argv[i];
1267 num_components++;
1268 }
1269
1270 /* Level 0 must have at least two components.
1271 Level 1 must have exactly two components.
1272 Level 5 must have at least three components. */
1273 if ((level == 0 && num_components < 2) ||
1274 (level == 1 && num_components != 2) ||
1275 (level == 5 && num_components < 3))
1276 usage();
1277
1278 /* build a config... */
1279
1280 memset(&cfg, 0, sizeof(cfg));
1281
1282 cfg.numCol = num_components;
1283 cfg.numSpare = 0;
1284
1285 for (i=0 ; i<num_components; i++) {
1286 strlcpy(cfg.devnames[0][i], components[i],
1287 sizeof(cfg.devnames[0][i]));
1288 }
1289
1290 /* pick some reasonable values for sectPerSU, etc. */
1291 if (level == 0) {
1292 if (num_components == 2) {
1293 /* 64 blocks (32K) per component - 64K data per stripe */
1294 cfg.sectPerSU = 64;
1295 } else if (num_components == 3 || num_components == 4) {
1296 /* 32 blocks (16K) per component - 64K data per strip for
1297 the 4-component case. */
1298 cfg.sectPerSU = 32;
1299 } else {
1300 /* 16 blocks (8K) per component */
1301 cfg.sectPerSU = 16;
1302 }
1303 } else if (level == 1) {
1304 /* 128 blocks (64K per component) - 64K per stripe */
1305 cfg.sectPerSU = 128;
1306 } else if (level == 5) {
1307 if (num_components == 3) {
1308 /* 64 blocks (32K) per disk - 64K data per stripe */
1309 cfg.sectPerSU = 64;
1310 } else if (num_components >= 4 && num_components < 9) {
1311 /* 4 components makes 3 data components. No power of 2 is
1312 evenly divisible by 3 so performance will be lousy
1313 regardless of what number we choose here. 5 components is
1314 what we are really hoping for here, as 5 components with 4
1315 data components on RAID 5 means 32 blocks (16K) per data
1316 component, or 64K per stripe */
1317 cfg.sectPerSU = 32;
1318 } else {
1319 /* 9 components here is optimal for 16 blocks (8K) per data
1320 component */
1321 cfg.sectPerSU = 16;
1322 }
1323 } else
1324 usage();
1325
1326 cfg.SUsPerPU = 1;
1327 cfg.SUsPerRU = 1;
1328 cfg.parityConfig = '0' + level;
1329 strlcpy(cfg.diskQueueType, "fifo", sizeof(cfg.diskQueueType));
1330 cfg.maxOutstandingDiskReqs = 1;
1331 cfg.force = 1;
1332
1333 /* configure... */
1334
1335 generic = &cfg;
1336 do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");
1337
1338 if (level == 1 || level == 5)
1339 do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
1340 "RAIDFRAME_REWRITEPARITY");
1341 }
1342
1343
1344 static void
1345 usage(void)
1346 {
1347 const char *progname = getprogname();
1348
1349 fprintf(stderr,
1350 "usage: %s dev create [0 | 1 | mirror | 5] component component ...\n",
1351 progname);
1352 fprintf(stderr, " %s [-v] -A [yes | no | softroot | hardroot] dev\n",
1353 progname);
1354 fprintf(stderr, " %s [-v] -a component dev\n", progname);
1355 fprintf(stderr, " %s [-v] -B dev\n", progname);
1356 fprintf(stderr, " %s [-v] -C config_file dev\n", progname);
1357 fprintf(stderr, " %s [-v] -c config_file dev\n", progname);
1358 fprintf(stderr, " %s [-v] -F component dev\n", progname);
1359 fprintf(stderr, " %s [-v] -f component dev\n", progname);
1360 fprintf(stderr, " %s [-v] -G dev\n", progname);
1361 fprintf(stderr, " %s [-v] -g component dev\n", progname);
1362 fprintf(stderr, " %s [-v] -I serial_number dev\n", progname);
1363 fprintf(stderr, " %s [-v] -i dev\n", progname);
1364 fprintf(stderr, " %s [-v] -M [yes | no | set params] dev\n",
1365 progname);
1366 fprintf(stderr, " %s [-v] -m dev\n", progname);
1367 fprintf(stderr, " %s [-v] -P dev\n", progname);
1368 fprintf(stderr, " %s [-v] -p dev\n", progname);
1369 fprintf(stderr, " %s [-v] -R component dev\n", progname);
1370 fprintf(stderr, " %s [-v] -r component dev\n", progname);
1371 fprintf(stderr, " %s [-v] -S dev\n", progname);
1372 fprintf(stderr, " %s [-v] -s dev\n", progname);
1373 fprintf(stderr, " %s [-v] -t config_file\n", progname);
1374 fprintf(stderr, " %s [-v] -U unit dev\n", progname);
1375 fprintf(stderr, " %s [-v] -u dev\n", progname);
1376 exit(1);
1377 /* NOTREACHED */
1378 }
1379
1380 static unsigned int
1381 xstrtouint(const char *str)
1382 {
1383 int e;
1384 unsigned int num = (unsigned int)strtou(str, NULL, 10, 0, INT_MAX, &e);
1385 if (e)
1386 errc(EXIT_FAILURE, e, "Bad number `%s'", str);
1387 return num;
1388 }
1389