1 /* $NetBSD: bioctl.c,v 1.20 2023/08/04 03:45:07 rin Exp $ */
2 /* $OpenBSD: bioctl.c,v 1.52 2007/03/20 15:26:06 jmc Exp $ */
3
4 /*
5 * Copyright (c) 2007, 2008 Juan Romero Pardines
6 * Copyright (c) 2004, 2005 Marco Peereboom
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
22 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 */
31 #include <sys/cdefs.h>
32
33 #ifndef lint
34 __RCSID("$NetBSD: bioctl.c,v 1.20 2023/08/04 03:45:07 rin Exp $");
35 #endif
36
37 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/param.h>
40 #include <sys/queue.h>
41 #include <dev/biovar.h>
42
43 #include <errno.h>
44 #include <err.h>
45 #include <fcntl.h>
46 #include <util.h>
47 #include <stdbool.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <unistd.h>
52 #include <ctype.h>
53 #include <util.h>
54
55 struct command {
56 const char *cmd_name;
57 const char *arg_names;
58 void (*cmd_func)(int, int, char **);
59 };
60
61 struct biotmp {
62 struct bioc_inq *bi;
63 struct bioc_vol *bv;
64 char volname[64];
65 int fd;
66 int volid;
67 int diskid;
68 bool format;
69 bool show_disknovol;
70 };
71
72 struct locator {
73 int channel;
74 int target;
75 int lun;
76 };
77
78 __dead static void usage(void);
79 static void bio_alarm(int, int, char **);
80 static void bio_show_common(int, int, char **);
81 static int bio_show_volumes(struct biotmp *, struct bioc_vol *);
82 static void bio_show_disks(struct biotmp *);
83 static void bio_setblink(int, int, char **);
84 static void bio_blink(int, char *, int, int);
85 static void bio_setstate_hotspare(int, int, char **);
86 static void bio_setstate_passthru(int, int, char **);
87 static void bio_setstate_common(int, char *, struct bioc_setstate *,
88 struct locator *);
89 static void bio_setstate_consistency(int, int, char **);
90 static void bio_volops_create(int, int, char **);
91 #ifdef notyet
92 static void bio_volops_modify(int, int, char **);
93 #endif
94 static void bio_volops_remove(int, int, char **);
95
96 static const char *str2locator(const char *, struct locator *);
97
98 static struct bio_locate bl;
99 static struct command commands[] = {
100 {
101 "show",
102 "[disks] | [volumes]",
103 bio_show_common },
104 {
105 "alarm",
106 "[enable] | [disable] | [silence] | [test]",
107 bio_alarm },
108 {
109 "blink",
110 "start [channel:target[.lun]] | stop [channel:target[.lun]]",
111 bio_setblink },
112 {
113 "hotspare",
114 "add channel:target.lun | remove channel:target.lun",
115 bio_setstate_hotspare },
116 {
117 "passthru",
118 "add DISKID channel:target.lun | remove channel:target.lun",
119 bio_setstate_passthru },
120 {
121 "check",
122 "start VOLID | stop VOLID",
123 bio_setstate_consistency },
124 {
125 "create",
126 "volume VOLID DISKIDs [SIZE] STRIPE RAID_LEVEL channel:target.lun",
127 bio_volops_create },
128 #ifdef notyet
129 {
130 "modify",
131 "volume VOLID STRIPE RAID_LEVEL channel:target.lun",
132 bio_volops_modify },
133 #endif
134 {
135 "remove",
136 "volume VOLID channel:target.lun",
137 bio_volops_remove },
138
139 { NULL, NULL, NULL }
140 };
141
142 int
main(int argc,char ** argv)143 main(int argc, char **argv)
144 {
145 char *dvname;
146 const char *cmdname;
147 int fd = 0, i;
148
149 /* Must have at least: device command */
150 if (argc < 3)
151 usage();
152
153 /* Skip program name, get and skip device name and command */
154 setprogname(*argv);
155 dvname = argv[1];
156 cmdname = argv[2];
157 argv += 3;
158 argc -= 3;
159
160 /* Look up and call the command */
161 for (i = 0; commands[i].cmd_name != NULL; i++)
162 if (strcmp(cmdname, commands[i].cmd_name) == 0)
163 break;
164 if (commands[i].cmd_name == NULL)
165 errx(EXIT_FAILURE, "unknown command: %s", cmdname);
166
167 /* Locate the device by issuing the BIOCLOCATE ioctl */
168 fd = open("/dev/bio", O_RDWR);
169 if (fd == -1)
170 err(EXIT_FAILURE, "Can't open /dev/bio");
171
172 bl.bl_name = dvname;
173 if (ioctl(fd, BIOCLOCATE, &bl) == -1)
174 errx(EXIT_FAILURE, "Can't locate %s device via /dev/bio",
175 bl.bl_name);
176
177 /* and execute the command */
178 (*commands[i].cmd_func)(fd, argc, argv);
179
180 (void)close(fd);
181 exit(EXIT_SUCCESS);
182 }
183
184 static void
usage(void)185 usage(void)
186 {
187 int i;
188
189 (void)fprintf(stderr, "usage: %s device command [arg [...]]\n",
190 getprogname());
191
192 (void)fprintf(stderr, "Available commands:\n");
193 for (i = 0; commands[i].cmd_name != NULL; i++)
194 (void)fprintf(stderr, " %s %s\n", commands[i].cmd_name,
195 commands[i].arg_names);
196
197 exit(EXIT_FAILURE);
198 /* NOTREACHED */
199 }
200
201 static const char *
str2locator(const char * string,struct locator * location)202 str2locator(const char *string, struct locator *location)
203 {
204 const char *errstr;
205 char parse[80], *targ, *lun;
206
207 strlcpy(parse, string, sizeof parse);
208 targ = strchr(parse, ':');
209 if (targ == NULL)
210 return "target not specified";
211
212 *targ++ = '\0';
213 lun = strchr(targ, '.');
214 if (lun != NULL) {
215 *lun++ = '\0';
216 location->lun = strtonum(lun, 0, 256, &errstr);
217 if (errstr)
218 return errstr;
219 } else
220 location->lun = 0;
221
222 location->target = strtonum(targ, 0, 256, &errstr);
223 if (errstr)
224 return errstr;
225 location->channel = strtonum(parse, 0, 256, &errstr);
226 if (errstr)
227 return errstr;
228 return NULL;
229 }
230
231 /*
232 * Shows info about available RAID volumes.
233 */
234 static int
bio_show_volumes(struct biotmp * bt,struct bioc_vol * bv)235 bio_show_volumes(struct biotmp *bt, struct bioc_vol *bv)
236 {
237 const char *status, *rtypestr, *stripestr;
238 char size[64], percent[16], seconds[20];
239 char rtype[16], stripe[16], tmp[48];
240
241 rtypestr = stripestr = NULL;
242
243 memset(bv, 0, sizeof(*bv));
244 bv->bv_cookie = bl.bl_cookie;
245 bv->bv_volid = bt->volid;
246 bv->bv_percent = -1;
247 bv->bv_seconds = 0;
248
249 if (ioctl(bt->fd, BIOCVOL, bv) == -1)
250 err(EXIT_FAILURE, "BIOCVOL");
251
252 percent[0] = '\0';
253 seconds[0] = '\0';
254 if (bv->bv_percent != -1)
255 snprintf(percent, sizeof(percent),
256 " %3.2f%% done", bv->bv_percent / 10.0);
257 if (bv->bv_seconds)
258 snprintf(seconds, sizeof(seconds),
259 " %u seconds", bv->bv_seconds);
260
261 switch (bv->bv_status) {
262 case BIOC_SVONLINE:
263 status = BIOC_SVONLINE_S;
264 break;
265 case BIOC_SVOFFLINE:
266 status = BIOC_SVOFFLINE_S;
267 break;
268 case BIOC_SVDEGRADED:
269 status = BIOC_SVDEGRADED_S;
270 break;
271 case BIOC_SVBUILDING:
272 status = BIOC_SVBUILDING_S;
273 break;
274 case BIOC_SVREBUILD:
275 status = BIOC_SVREBUILD_S;
276 break;
277 case BIOC_SVMIGRATING:
278 status = BIOC_SVMIGRATING_S;
279 break;
280 case BIOC_SVSCRUB:
281 status = BIOC_SVSCRUB_S;
282 break;
283 case BIOC_SVCHECKING:
284 status = BIOC_SVCHECKING_S;
285 break;
286 case BIOC_SVINVALID:
287 default:
288 status = BIOC_SVINVALID_S;
289 break;
290 }
291
292 snprintf(bt->volname, sizeof(bt->volname), "%u", bv->bv_volid);
293 if (bv->bv_vendor[0])
294 snprintf(tmp, sizeof(tmp), "%s %s", bv->bv_dev, bv->bv_vendor);
295 else
296 snprintf(tmp, sizeof(tmp), "%s", bv->bv_dev);
297
298 switch (bv->bv_level) {
299 case BIOC_SVOL_HOTSPARE:
300 rtypestr = "Hot spare";
301 stripestr = "N/A";
302 break;
303 case BIOC_SVOL_PASSTHRU:
304 rtypestr = "Pass through";
305 stripestr = "N/A";
306 break;
307 case BIOC_SVOL_RAID01:
308 rtypestr = "RAID 0+1";
309 break;
310 case BIOC_SVOL_RAID10:
311 rtypestr = "RAID 1+0";
312 break;
313 default:
314 snprintf(rtype, sizeof(rtype), "RAID %u", bv->bv_level);
315 if (bv->bv_level == 1 || bv->bv_stripe_size == 0)
316 stripestr = "N/A";
317 break;
318 }
319
320 if (rtypestr)
321 strlcpy(rtype, rtypestr, sizeof(rtype));
322 if (stripestr)
323 strlcpy(stripe, stripestr, sizeof(stripe));
324 else
325 snprintf(stripe, sizeof(stripe), "%uK", bv->bv_stripe_size);
326
327 humanize_number(size, 5, (int64_t)bv->bv_size, "", HN_AUTOSCALE,
328 HN_B | HN_NOSPACE | HN_DECIMAL);
329
330 printf("%6s %-12s %4s %20s %8s %6s %s%s\n",
331 bt->volname, status, size, tmp,
332 rtype, stripe, percent, seconds);
333
334 bt->bv = bv;
335
336 return bv->bv_nodisk;
337 }
338
339 /*
340 * Shows info about physical disks.
341 */
342 static void
bio_show_disks(struct biotmp * bt)343 bio_show_disks(struct biotmp *bt)
344 {
345 struct bioc_disk bd;
346 const char *status;
347 char size[64], serial[32], scsiname[34];
348
349 memset(&bd, 0, sizeof(bd));
350 bd.bd_cookie = bl.bl_cookie;
351 bd.bd_diskid = bt->diskid;
352 bd.bd_volid = bt->volid;
353
354 if (bt->show_disknovol) {
355 if (ioctl(bt->fd, BIOCDISK_NOVOL, &bd) == -1)
356 err(EXIT_FAILURE, "BIOCDISK_NOVOL");
357 if (!bd.bd_disknovol)
358 return;
359 } else {
360 if (ioctl(bt->fd, BIOCDISK, &bd) == -1)
361 err(EXIT_FAILURE, "BIOCDISK");
362 }
363
364 switch (bd.bd_status) {
365 case BIOC_SDONLINE:
366 status = BIOC_SDONLINE_S;
367 break;
368 case BIOC_SDOFFLINE:
369 status = BIOC_SDOFFLINE_S;
370 break;
371 case BIOC_SDFAILED:
372 status = BIOC_SDFAILED_S;
373 break;
374 case BIOC_SDREBUILD:
375 status = BIOC_SDREBUILD_S;
376 break;
377 case BIOC_SDHOTSPARE:
378 status = BIOC_SDHOTSPARE_S;
379 break;
380 case BIOC_SDUNUSED:
381 status = BIOC_SDUNUSED_S;
382 break;
383 case BIOC_SDSCRUB:
384 status = BIOC_SDSCRUB_S;
385 break;
386 case BIOC_SDPASSTHRU:
387 status = BIOC_SDPASSTHRU_S;
388 break;
389 case BIOC_SDINVALID:
390 default:
391 status = BIOC_SDINVALID_S;
392 break;
393 }
394
395 if (bt->format)
396 snprintf(bt->volname, sizeof(bt->volname),
397 "%u:%u", bt->bv->bv_volid, bd.bd_diskid);
398
399 humanize_number(size, 5, bd.bd_size, "", HN_AUTOSCALE,
400 HN_B | HN_NOSPACE | HN_DECIMAL);
401
402 if (bd.bd_procdev[0])
403 snprintf(scsiname, sizeof(scsiname), "%u:%u.%u %s",
404 bd.bd_channel, bd.bd_target, bd.bd_lun,
405 bd.bd_procdev);
406 else
407 snprintf(scsiname, sizeof(scsiname), "%u:%u.%u noencl",
408 bd.bd_channel, bd.bd_target, bd.bd_lun);
409
410 if (bd.bd_serial[0])
411 strlcpy(serial, bd.bd_serial, sizeof(serial));
412 else
413 strlcpy(serial, "unknown serial", sizeof(serial));
414
415 if (bt->format)
416 printf("%6s %-12s %4s %20s <%s>\n",
417 bt->volname, status, size, scsiname,
418 bd.bd_vendor);
419 else
420 printf("%5d [%-28s] %-12s %-6s %12s\n",
421 bt->diskid, bd.bd_vendor, status, size, scsiname);
422
423 }
424
425 /*
426 * Shows info about volumes/disks.
427 */
428 static void
bio_show_common(int fd,int argc,char ** argv)429 bio_show_common(int fd, int argc, char **argv)
430 {
431 struct biotmp *biot;
432 struct bioc_inq bi;
433 struct bioc_vol bv;
434 int i, d, ndisks;
435 bool show_all, show_disks;
436 bool show_vols, show_caps;
437
438 show_all = show_disks = show_vols = show_caps = false;
439
440 if (argc > 1)
441 usage();
442
443 if (argv[0]) {
444 if (strcmp(argv[0], "disks") == 0)
445 show_disks = true;
446 else if (strcmp(argv[0], "volumes") == 0)
447 show_vols = true;
448 else
449 usage();
450 } else
451 show_all = true;
452
453 memset(&bi, 0, sizeof(bi));
454 bi.bi_cookie = bl.bl_cookie;
455
456 if (ioctl(fd, BIOCINQ, &bi) == -1)
457 err(EXIT_FAILURE, "BIOCINQ");
458
459 /*
460 * If there are volumes there's no point to continue.
461 */
462 if (show_all || show_vols) {
463 if (!bi.bi_novol) {
464 warnx("no volumes available");
465 return;
466 }
467 }
468
469 biot = calloc(1, sizeof(*biot));
470 if (!biot)
471 err(EXIT_FAILURE, "biotemp calloc");
472
473 biot->fd = fd;
474 biot->bi = &bi;
475 /*
476 * Go to the disks section if that was specified.
477 */
478 if (show_disks)
479 goto disks;
480
481 /*
482 * Common code to show only info about volumes and disks
483 * associated to them.
484 */
485 printf("%6s %-12s %4s %20s %8s %6s\n",
486 "Volume", "Status", "Size", "Device/Label",
487 "Level", "Stripe");
488 printf("=============================================="
489 "===============\n");
490
491 for (i = 0; i < bi.bi_novol; i++) {
492 biot->format = true;
493 biot->volid = i;
494 ndisks = bio_show_volumes(biot, &bv);
495 if (show_vols)
496 continue;
497
498 for (d = 0; d < ndisks; d++) {
499 biot->diskid = d;
500 bio_show_disks(biot);
501 }
502
503 }
504 goto out;
505
506 disks:
507 /*
508 * show info about all disks connected to the raid controller,
509 * even if they aren't associated with a volume or raid set.
510 */
511 if (show_disks) {
512 printf("%5s %-30s %-12s %-6s %12s\n",
513 "Disk", "Model/Serial", "Status", "Size", "Location");
514 printf("==============================================="
515 "======================\n");
516 for (d = 0; d < bi.bi_nodisk; d++) {
517 biot->show_disknovol = true;
518 biot->diskid = d;
519 bio_show_disks(biot);
520 }
521 }
522 out:
523 free(biot);
524 }
525
526 /*
527 * To handle the alarm feature.
528 */
529 static void
bio_alarm(int fd,int argc,char ** argv)530 bio_alarm(int fd, int argc, char **argv)
531 {
532 struct bioc_alarm ba;
533 bool show = false;
534
535 memset(&ba, 0, sizeof(ba));
536 ba.ba_cookie = bl.bl_cookie;
537
538 if (argc > 1)
539 usage();
540
541 if (argc == 0) {
542 /* show alarm status */
543 ba.ba_opcode = BIOC_GASTATUS;
544 show = true;
545 } else if (strcmp(argv[0], "silence") == 0) {
546 /* silence alarm */
547 ba.ba_opcode = BIOC_SASILENCE;
548 } else if (strcmp(argv[0], "enable") == 0) {
549 /* enable alarm */
550 ba.ba_opcode = BIOC_SAENABLE;
551 } else if (strcmp(argv[0], "disable") == 0) {
552 /* disable alarm */
553 ba.ba_opcode = BIOC_SADISABLE;
554 } else if (strcmp(argv[0], "test") == 0) {
555 /* test alarm */
556 ba.ba_opcode = BIOC_SATEST;
557 } else
558 usage();
559
560 if (ioctl(fd, BIOCALARM, &ba) == -1)
561 err(EXIT_FAILURE, "BIOCALARM");
562
563 if (show)
564 printf("alarm is currently %s\n",
565 ba.ba_status ? "enabled" : "disabled");
566 }
567
568 /*
569 * To add/remove a hotspare disk.
570 */
571 static void
bio_setstate_hotspare(int fd,int argc,char ** argv)572 bio_setstate_hotspare(int fd, int argc, char **argv)
573 {
574 struct bioc_setstate bs;
575 struct locator location;
576
577 memset(&bs, 0, sizeof(bs));
578
579 if (argc != 2)
580 usage();
581
582 if (strcmp(argv[0], "add") == 0)
583 bs.bs_status = BIOC_SSHOTSPARE;
584 else if (strcmp(argv[0], "remove") == 0)
585 bs.bs_status = BIOC_SSDELHOTSPARE;
586 else
587 usage();
588
589 bio_setstate_common(fd, argv[1], &bs, &location);
590 }
591
592 /*
593 * To add/remove a pass through disk.
594 */
595 static void
bio_setstate_passthru(int fd,int argc,char ** argv)596 bio_setstate_passthru(int fd, int argc, char **argv)
597 {
598 struct bioc_setstate bs;
599 struct locator location;
600 char *endptr;
601 bool rem = false;
602
603 if (argc < 2 || argc > 3)
604 usage();
605
606 memset(&bs, 0, sizeof(bs));
607
608 if (strcmp(argv[0], "add") == 0) {
609 if (argv[1] == NULL || argv[2] == NULL)
610 usage();
611
612 bs.bs_status = BIOC_SSPASSTHRU;
613 } else if (strcmp(argv[0], "remove") == 0) {
614 if (argv[1] == NULL)
615 usage();
616
617 bs.bs_status = BIOC_SSDELPASSTHRU;
618 rem = true;
619 } else
620 usage();
621
622 if (rem)
623 bio_setstate_common(fd, argv[1], &bs, &location);
624 else {
625 bs.bs_other_id = (unsigned int)strtoul(argv[1], &endptr, 10);
626 if (*endptr != '\0')
627 errx(EXIT_FAILURE, "Invalid Volume ID value");
628
629 bio_setstate_common(fd, argv[2], &bs, &location);
630 }
631 }
632
633 /*
634 * To start/stop a consistency check in a RAID volume.
635 */
636 static void
bio_setstate_consistency(int fd,int argc,char ** argv)637 bio_setstate_consistency(int fd, int argc, char **argv)
638 {
639 struct bioc_setstate bs;
640 char *endptr;
641
642 if (argc != 2)
643 usage();
644
645 memset(&bs, 0, sizeof(bs));
646
647 if (strcmp(argv[0], "start") == 0)
648 bs.bs_status = BIOC_SSCHECKSTART_VOL;
649 else if (strcmp(argv[0], "stop") == 0)
650 bs.bs_status = BIOC_SSCHECKSTOP_VOL;
651 else
652 usage();
653
654 bs.bs_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
655 if (*endptr != '\0')
656 errx(EXIT_FAILURE, "Invalid Volume ID value");
657
658 bio_setstate_common(fd, NULL, &bs, NULL);
659 }
660
661 static void
bio_setstate_common(int fd,char * arg,struct bioc_setstate * bs,struct locator * location)662 bio_setstate_common(int fd, char *arg, struct bioc_setstate *bs,
663 struct locator *location)
664 {
665 const char *errstr;
666
667 if (!arg || !location)
668 goto send;
669
670 errstr = str2locator(arg, location);
671 if (errstr)
672 errx(EXIT_FAILURE, "Target %s: %s", arg, errstr);
673
674 bs->bs_channel = location->channel;
675 bs->bs_target = location->target;
676 bs->bs_lun = location->lun;
677
678 send:
679 bs->bs_cookie = bl.bl_cookie;
680
681 if (ioctl(fd, BIOCSETSTATE, bs) == -1)
682 err(EXIT_FAILURE, "BIOCSETSTATE");
683 }
684
685 /*
686 * To create a RAID volume.
687 */
688 static void
bio_volops_create(int fd,int argc,char ** argv)689 bio_volops_create(int fd, int argc, char **argv)
690 {
691 struct bioc_volops bc;
692 struct bioc_inq bi;
693 struct bioc_disk bd;
694 struct locator location;
695 uint64_t total_size = 0, disksize = 0;
696 int64_t volsize = 0;
697 const char *errstr;
698 char *endptr, *stripe, levelstr[32];
699 char *scsiname, *raid_level, size[64];
700 int disk_first = 0, disk_end = 0;
701 int i, nfreedisks = 0;
702 int user_disks = 0;
703
704 if (argc < 6 || argc > 7)
705 usage();
706
707 if (strcmp(argv[0], "volume") != 0)
708 usage();
709
710 /*
711 * No size requested, use max size depending on RAID level.
712 */
713 if (argc == 6) {
714 stripe = argv[3];
715 raid_level = argv[4];
716 scsiname = argv[5];
717 } else {
718 stripe = argv[4];
719 raid_level = argv[5];
720 scsiname = argv[6];
721 }
722
723 memset(&bd, 0, sizeof(bd));
724 memset(&bc, 0, sizeof(bc));
725 memset(&bi, 0, sizeof(bi));
726
727 bc.bc_cookie = bd.bd_cookie = bi.bi_cookie = bl.bl_cookie;
728 bc.bc_opcode = BIOC_VCREATE_VOLUME;
729
730 bc.bc_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
731 if (*endptr != '\0')
732 errx(EXIT_FAILURE, "Invalid Volume ID value");
733
734 if (argc == 7)
735 if (dehumanize_number(argv[3], &volsize) == -1
736 || volsize < 0)
737 errx(EXIT_FAILURE, "Invalid SIZE value");
738
739 bc.bc_stripe = (unsigned int)strtoul(stripe, &endptr, 10);
740 if (*endptr != '\0')
741 errx(EXIT_FAILURE, "Invalid STRIPE size value");
742
743 bc.bc_level = (unsigned int)strtoul(raid_level, &endptr, 10);
744 if (*endptr != '\0')
745 errx(EXIT_FAILURE, "Invalid RAID_LEVEL value");
746
747 errstr = str2locator(scsiname, &location);
748 if (errstr)
749 errx(EXIT_FAILURE, "Target %s: %s", scsiname, errstr);
750
751 /*
752 * Parse the device list that will be used for the volume,
753 * by using a bit field for the disks.
754 */
755 if ((isdigit((unsigned char)argv[2][0]) == 0) || argv[2][1] != '-' ||
756 (isdigit((unsigned char)argv[2][2]) == 0))
757 errx(EXIT_FAILURE, "Invalid DISKIDs value");
758
759 disk_first = atoi(&argv[2][0]);
760 disk_end = atoi(&argv[2][2]);
761
762 for (i = disk_first; i < disk_end + 1; i++) {
763 bc.bc_devmask |= (1 << i);
764 user_disks++;
765 }
766
767 /*
768 * Find out how many disks are free and how much size we
769 * have available for the new volume.
770 */
771 if (ioctl(fd, BIOCINQ, &bi) == -1)
772 err(EXIT_FAILURE, "BIOCINQ");
773
774 for (i = 0; i < bi.bi_nodisk; i++) {
775 bd.bd_diskid = i;
776 if (ioctl(fd, BIOCDISK_NOVOL, &bd) == -1)
777 err(EXIT_FAILURE, "BIOCDISK_NOVOL");
778
779 if (bd.bd_status == BIOC_SDUNUSED) {
780 if (i == 0)
781 disksize = bd.bd_size;
782
783 total_size += bd.bd_size;
784 nfreedisks++;
785 }
786 }
787
788 if (user_disks > nfreedisks)
789 errx(EXIT_FAILURE, "specified disks number is higher than "
790 "available free disks");
791
792 /*
793 * Basic checks to be sure we don't do something stupid.
794 */
795 if (nfreedisks == 0)
796 errx(EXIT_FAILURE, "No free disks available");
797
798 switch (bc.bc_level) {
799 case 0: /* RAID 0 requires at least one disk */
800 if (argc == 7) {
801 if ((uint64_t)volsize > (disksize * user_disks))
802 errx(EXIT_FAILURE, "volume size specified "
803 "is larger than available on free disks");
804 bc.bc_size = (uint64_t)volsize;
805 } else
806 bc.bc_size = disksize * user_disks;
807
808 break;
809 case 1: /* RAID 1 requires two disks and size is total / 2 */
810 if (nfreedisks < 2 || user_disks < 2)
811 errx(EXIT_FAILURE, "2 disks are required at least for "
812 "this RAID level");
813
814 /* RAID 1+0 requires three disks at least */
815 if (nfreedisks > 2 && user_disks > 2)
816 bc.bc_level = BIOC_SVOL_RAID10;
817
818 if (argc == 7) {
819 if ((uint64_t)volsize > ((disksize * user_disks) / 2))
820 errx(EXIT_FAILURE, "volume size specified "
821 "is larger than available on free disks");
822 bc.bc_size = (uint64_t)volsize;
823 } else
824 bc.bc_size = ((disksize * user_disks) / 2);
825
826 break;
827 case 3: /* RAID 3/5 requires three disks and size is total - 1 disk */
828 case 5:
829 if (nfreedisks < 3 || user_disks < 3)
830 errx(EXIT_FAILURE, "3 disks are required at least for "
831 "this RAID level");
832
833 if (argc == 7) {
834 if ((uint64_t)volsize > (disksize * (user_disks - 1)))
835 errx(EXIT_FAILURE, "volume size specified "
836 "is larger than available on free disks");
837 bc.bc_size = (uint64_t)volsize;
838 } else
839 bc.bc_size = (disksize * (user_disks - 1));
840
841 break;
842 case 6: /* RAID 6 requires four disks and size is total - 2 disks */
843 if (nfreedisks < 4 || user_disks < 4)
844 errx(EXIT_FAILURE, "4 disks are required at least for "
845 "this RAID level");
846
847 if (argc == 7) {
848 if ((uint64_t)volsize >
849 ((disksize * user_disks) - (disksize * 2)))
850 err(EXIT_FAILURE, "volume size specified "
851 "is larger than available on free disks");
852 bc.bc_size = (uint64_t)volsize;
853 } else
854 bc.bc_size =
855 (((disksize * user_disks) - (disksize * 2)));
856
857 break;
858 default:
859 errx(EXIT_FAILURE, "Unsupported RAID level");
860 }
861
862 bc.bc_channel = location.channel;
863 bc.bc_target = location.target;
864 bc.bc_lun = location.lun;
865
866 if (ioctl(fd, BIOCVOLOPS, &bc) == -1)
867 err(EXIT_FAILURE, "BIOCVOLOPS");
868
869 humanize_number(size, 5, bc.bc_size, "", HN_AUTOSCALE,
870 HN_B | HN_NOSPACE | HN_DECIMAL);
871
872 if (bc.bc_level == BIOC_SVOL_RAID10)
873 snprintf(levelstr, sizeof(levelstr), "1+0");
874 else
875 snprintf(levelstr, sizeof(levelstr), "%u", bc.bc_level);
876
877 printf("Created volume %u size: %s stripe: %uK level: %s "
878 "SCSI location: %u:%u.%u\n", bc.bc_volid, size, bc.bc_stripe,
879 levelstr, bc.bc_channel, bc.bc_target, bc.bc_lun);
880 }
881
882 #ifdef notyet
883 /*
884 * To modify a RAID volume.
885 */
886 static void
bio_volops_modify(int fd,int argc,char ** argv)887 bio_volops_modify(int fd, int argc, char **argv)
888 {
889 /* XTRAEME: TODO */
890 }
891 #endif
892
893 /*
894 * To remove a RAID volume.
895 */
896 static void
bio_volops_remove(int fd,int argc,char ** argv)897 bio_volops_remove(int fd, int argc, char **argv)
898 {
899 struct bioc_volops bc;
900 struct locator location;
901 const char *errstr;
902 char *endptr;
903
904 if (argc != 3 || strcmp(argv[0], "volume") != 0)
905 usage();
906
907 memset(&bc, 0, sizeof(bc));
908 bc.bc_cookie = bl.bl_cookie;
909 bc.bc_opcode = BIOC_VREMOVE_VOLUME;
910
911 bc.bc_volid = (unsigned int)strtoul(argv[1], &endptr, 10);
912 if (*endptr != '\0')
913 errx(EXIT_FAILURE, "Invalid Volume ID value");
914
915 errstr = str2locator(argv[2], &location);
916 if (errstr)
917 errx(EXIT_FAILURE, "Target %s: %s", argv[2], errstr);
918
919 bc.bc_channel = location.channel;
920 bc.bc_target = location.target;
921 bc.bc_lun = location.lun;
922
923 if (ioctl(fd, BIOCVOLOPS, &bc) == -1)
924 err(EXIT_FAILURE, "BIOCVOLOPS");
925
926 printf("Removed volume %u at SCSI location %u:%u.%u\n",
927 bc.bc_volid, bc.bc_channel, bc.bc_target, bc.bc_lun);
928 }
929
930 /*
931 * To blink/unblink a disk in enclosures.
932 */
933 static void
bio_setblink(int fd,int argc,char ** argv)934 bio_setblink(int fd, int argc, char **argv)
935 {
936 struct locator location;
937 struct bioc_inq bi;
938 struct bioc_vol bv;
939 struct bioc_disk bd;
940 struct bioc_blink bb;
941 const char *errstr;
942 int v, d, rv, blink = 0;
943
944 if (argc != 2)
945 usage();
946
947 if (strcmp(argv[0], "start") == 0)
948 blink = BIOC_SBBLINK;
949 else if (strcmp(argv[0], "stop") == 0)
950 blink = BIOC_SBUNBLINK;
951 else
952 usage();
953
954 errstr = str2locator(argv[1], &location);
955 if (errstr)
956 errx(EXIT_FAILURE, "Target %s: %s", argv[1], errstr);
957
958 /* try setting blink on the device directly */
959 memset(&bb, 0, sizeof(bb));
960 bb.bb_cookie = bl.bl_cookie;
961 bb.bb_status = blink;
962 bb.bb_target = location.target;
963 bb.bb_channel = location.channel;
964 rv = ioctl(fd, BIOCBLINK, &bb);
965 if (rv == 0)
966 return;
967
968 /* if the blink didnt work, try to find something that will */
969 memset(&bi, 0, sizeof(bi));
970 bi.bi_cookie = bl.bl_cookie;
971 rv = ioctl(fd, BIOCINQ, &bi);
972 if (rv == -1)
973 err(EXIT_FAILURE, "BIOCINQ");
974
975 for (v = 0; v < bi.bi_novol; v++) {
976 memset(&bv, 0, sizeof(bv));
977 bv.bv_cookie = bl.bl_cookie;
978 bv.bv_volid = v;
979 rv = ioctl(fd, BIOCVOL, &bv);
980 if (rv == -1)
981 err(EXIT_FAILURE, "BIOCVOL");
982
983 for (d = 0; d < bv.bv_nodisk; d++) {
984 memset(&bd, 0, sizeof(bd));
985 bd.bd_cookie = bl.bl_cookie;
986 bd.bd_volid = v;
987 bd.bd_diskid = d;
988
989 rv = ioctl(fd, BIOCDISK, &bd);
990 if (rv == -1)
991 err(EXIT_FAILURE, "BIOCDISK");
992
993 if (bd.bd_channel == location.channel &&
994 bd.bd_target == location.target &&
995 bd.bd_lun == location.lun) {
996 if (bd.bd_procdev[0] != '\0') {
997 bio_blink(fd, bd.bd_procdev,
998 location.target, blink);
999 } else
1000 warnx("Disk %s is not in an enclosure",
1001 argv[1]);
1002 return;
1003 }
1004 }
1005 }
1006
1007 warnx("Disk %s does not exist", argv[1]);
1008 }
1009
1010 static void
bio_blink(int fd,char * enclosure,int target,int blinktype)1011 bio_blink(int fd, char *enclosure, int target, int blinktype)
1012 {
1013 struct bio_locate bio;
1014 struct bioc_blink blink;
1015
1016 bio.bl_name = enclosure;
1017 if (ioctl(fd, BIOCLOCATE, &bio) == -1)
1018 errx(EXIT_FAILURE,
1019 "Can't locate %s device via /dev/bio", enclosure);
1020
1021 memset(&blink, 0, sizeof(blink));
1022 blink.bb_cookie = bio.bl_cookie;
1023 blink.bb_status = blinktype;
1024 blink.bb_target = target;
1025
1026 if (ioctl(fd, BIOCBLINK, &blink) == -1)
1027 err(EXIT_FAILURE, "BIOCBLINK");
1028 }
1029