sbin/bioctl/bioctl.c

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