bin/chio/chio.c

   1 /*      $NetBSD: chio.c,v 1.6 1998/01/04 23:53:58 thorpej Exp $ */
   2 /*
   3  * Copyright (c) 1996 Jason R. Thorpe <thorpej@and.com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgements:
  16  *      This product includes software developed by Jason R. Thorpe
  17  *      for And Communications, http://www.and.com/
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 /*
  34  * Additional Copyright (c) 1997, by Matthew Jacob, for NASA/Ames Research Ctr.
  35  * Addidional Copyright (c) 2000, by C. Stephen Gunn, Waterspout Communications
  36  */
  37
  38 #ifndef lint
  39 static const char copyright[] =
  40         "@(#) Copyright (c) 1996 Jason R. Thorpe.  All rights reserved.";
  41 static const char rcsid[] =
  42   "$FreeBSD: src/bin/chio/chio.c,v 1.15.2.3 2001/07/28 19:22:01 mikeh Exp $";
  43 #endif /* not lint */
  44
  45 #include <sys/param.h>
  46 #include <sys/chio.h>
  47 #include <err.h>
  48 #include <fcntl.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #include "defs.h"
  55 #include "pathnames.h"
  56
  57 extern  char *__progname;       /* from crt0.o */
  58
  59 static  void usage __P((void));
  60 static  void cleanup __P((void));
  61 static  int parse_element_type __P((char *));
  62 static  int parse_element_unit __P((char *));
  63 static  const char * element_type_name __P((int et));
  64 static  int parse_special __P((char *));
  65 static  int is_special __P((char *));
  66 static  const char *bits_to_string __P((ces_status_flags, const char *));
  67
  68 static  void find_element __P((char *, u_int16_t *, u_int16_t *));
  69 static  struct changer_element_status *get_element_status
  70             __P((unsigned int, unsigned int));
  71
  72 static  int do_move __P((const char *, int, char **));
  73 static  int do_exchange __P((const char *, int, char **));
  74 static  int do_position __P((const char *, int, char **));
  75 static  int do_params __P((const char *, int, char **));
  76 static  int do_getpicker __P((const char *, int, char **));
  77 static  int do_setpicker __P((const char *, int, char **));
  78 static  int do_status __P((const char *, int, char **));
  79 static  int do_ielem __P((const char *, int, char **));
  80 static  int do_return __P((const char *, int, char **));
  81 static  int do_voltag __P((const char *, int, char **));
  82
  83 #ifndef CHET_VT
  84 #define CHET_VT         10                      /* Completely Arbitrary */
  85 #endif
  86
  87 /* Valid changer element types. */
  88 const struct element_type elements[] = {
  89         { "drive",              CHET_DT },
  90         { "picker",             CHET_MT },
  91         { "portal",             CHET_IE },
  92         { "slot",               CHET_ST },
  93         { "voltag",             CHET_VT },      /* Select tapes by barcode */
  94         { NULL,                 0 },
  95 };
  96
  97 /* Valid commands. */
  98 const struct changer_command commands[] = {
  99         { "exchange",           do_exchange },
 100         { "getpicker",          do_getpicker },
 101         { "ielem",              do_ielem },
 102         { "move",               do_move },
 103         { "params",             do_params },
 104         { "position",           do_position },
 105         { "setpicker",          do_setpicker },
 106         { "status",             do_status },
 107         { "return",             do_return },
 108         { "voltag",             do_voltag },
 109         { NULL,                 0 },
 110 };
 111
 112 /* Valid special words. */
 113 const struct special_word specials[] = {
 114         { "inv",                SW_INVERT },
 115         { "inv1",               SW_INVERT1 },
 116         { "inv2",               SW_INVERT2 },
 117         { NULL,                 0 },
 118 };
 119
 120 static  int changer_fd;
 121 static  const char *changer_name;
 122
 123 int
 124 main(argc, argv)
 125         int argc;
 126         char **argv;
 127 {
 128         int ch, i;
 129
 130         while ((ch = getopt(argc, argv, "f:")) != -1) {
 131                 switch (ch) {
 132                 case 'f':
 133                         changer_name = optarg;
 134                         break;
 135
 136                 default:
 137                         usage();
 138                 }
 139         }
 140         argc -= optind;
 141         argv += optind;
 142
 143         if (argc == 0)
 144                 usage();
 145
 146         /* Get the default changer if not already specified. */
 147         if (changer_name == NULL)
 148                 if ((changer_name = getenv(CHANGER_ENV_VAR)) == NULL)
 149                         changer_name = _PATH_CH;
 150
 151         /* Open the changer device. */
 152         if ((changer_fd = open(changer_name, O_RDWR, 0600)) == -1)
 153                 err(1, "%s: open", changer_name);
 154
 155         /* Register cleanup function. */
 156         if (atexit(cleanup))
 157                 err(1, "can't register cleanup function");
 158
 159         /* Find the specified command. */
 160         for (i = 0; commands[i].cc_name != NULL; ++i)
 161                 if (strcmp(*argv, commands[i].cc_name) == 0)
 162                         break;
 163         if (commands[i].cc_name == NULL) {
 164                 /* look for abbreviation */
 165                 for (i = 0; commands[i].cc_name != NULL; ++i)
 166                         if (strncmp(*argv, commands[i].cc_name,
 167                             strlen(*argv)) == 0)
 168                                 break;
 169         }
 170
 171         if (commands[i].cc_name == NULL)
 172                 errx(1, "unknown command: %s", *argv);
 173
 174         exit ((*commands[i].cc_handler)(commands[i].cc_name, argc, argv));
 175         /* NOTREACHED */
 176 }
 177
 178 static int
 179 do_move(cname, argc, argv)
 180         const char *cname;
 181         int argc;
 182         char **argv;
 183 {
 184         struct changer_move cmd;
 185         int val;
 186
 187         /*
 188          * On a move command, we expect the following:
 189          *
 190          * <from ET> <from EU> <to ET> <to EU> [inv]
 191          *
 192          * where ET == element type and EU == element unit.
 193          */
 194
 195         ++argv; --argc;
 196
 197         if (argc < 4) {
 198                 warnx("%s: too few arguments", cname);
 199                 goto usage;
 200         } else if (argc > 5) {
 201                 warnx("%s: too many arguments", cname);
 202                 goto usage;
 203         }
 204         (void) memset(&cmd, 0, sizeof(cmd));
 205
 206         /* <from ET>  */
 207         cmd.cm_fromtype = parse_element_type(*argv);
 208         ++argv; --argc;
 209
 210         /* Check for voltag virtual type */
 211         if (CHET_VT == cmd.cm_fromtype) {
 212                 find_element(*argv, &cmd.cm_fromtype, &cmd.cm_fromunit);
 213         } else {
 214                 /* <from EU> */
 215                 cmd.cm_fromunit = parse_element_unit(*argv);
 216         }
 217         ++argv; --argc;
 218
 219         /* <to ET> */
 220         cmd.cm_totype = parse_element_type(*argv);
 221         ++argv; --argc;
 222
 223         /* Check for voltag virtual type, and report error */
 224         if (CHET_VT == cmd.cm_totype)
 225                 errx(1,"%s: voltag only makes sense as an element source",
 226                      cname);
 227
 228         /* <to EU> */
 229         cmd.cm_tounit = parse_element_unit(*argv);
 230         ++argv; --argc;
 231
 232         /* Deal with optional command modifier. */
 233         if (argc) {
 234                 val = parse_special(*argv);
 235                 switch (val) {
 236                 case SW_INVERT:
 237                         cmd.cm_flags |= CM_INVERT;
 238                         break;
 239
 240                 default:
 241                         errx(1, "%s: inappropriate modifier `%s'",
 242                             cname, *argv);
 243                         /* NOTREACHED */
 244                 }
 245         }
 246
 247         /* Send command to changer. */
 248         if (ioctl(changer_fd, CHIOMOVE, &cmd))
 249                 err(1, "%s: CHIOMOVE", changer_name);
 250
 251         return (0);
 252
 253  usage:
 254         (void) fprintf(stderr, "usage: %s %s "
 255             "<from ET> <from EU> <to ET> <to EU> [inv]\n", __progname, cname);
 256         return (1);
 257 }
 258
 259 static int
 260 do_exchange(cname, argc, argv)
 261         const char *cname;
 262         int argc;
 263         char **argv;
 264 {
 265         struct changer_exchange cmd;
 266         int val;
 267
 268         /*
 269          * On an exchange command, we expect the following:
 270          *
 271   * <src ET> <src EU> <dst1 ET> <dst1 EU> [<dst2 ET> <dst2 EU>] [inv1] [inv2]
 272          *
 273          * where ET == element type and EU == element unit.
 274          */
 275
 276         ++argv; --argc;
 277
 278         if (argc < 4) {
 279                 warnx("%s: too few arguments", cname);
 280                 goto usage;
 281         } else if (argc > 8) {
 282                 warnx("%s: too many arguments", cname);
 283                 goto usage;
 284         }
 285         (void) memset(&cmd, 0, sizeof(cmd));
 286
 287         /* <src ET>  */
 288         cmd.ce_srctype = parse_element_type(*argv);
 289         ++argv; --argc;
 290
 291         /* Check for voltag virtual type */
 292         if (CHET_VT == cmd.ce_srctype) {
 293                 find_element(*argv, &cmd.ce_srctype, &cmd.ce_srcunit);
 294         } else {
 295                 /* <from EU> */
 296                 cmd.ce_srcunit = parse_element_unit(*argv);
 297         }
 298         ++argv; --argc;
 299
 300         /* <dst1 ET> */
 301         cmd.ce_fdsttype = parse_element_type(*argv);
 302         ++argv; --argc;
 303
 304         /* Check for voltag virtual type */
 305         if (CHET_VT == cmd.ce_fdsttype) {
 306                 find_element(*argv, &cmd.ce_fdsttype, &cmd.ce_fdstunit);
 307         } else {
 308                 /* <from EU> */
 309                 cmd.ce_fdstunit = parse_element_unit(*argv);
 310         }
 311         ++argv; --argc;
 312
 313         /*
 314          * If the next token is a special word or there are no more
 315          * arguments, then this is a case of simple exchange.
 316          * dst2 == src.
 317          */
 318         if ((argc == 0) || is_special(*argv)) {
 319                 cmd.ce_sdsttype = cmd.ce_srctype;
 320                 cmd.ce_sdstunit = cmd.ce_srcunit;
 321                 goto do_special;
 322         }
 323
 324         /* <dst2 ET> */
 325         cmd.ce_sdsttype = parse_element_type(*argv);
 326         ++argv; --argc;
 327
 328         if (CHET_VT == cmd.ce_sdsttype)
 329                 errx(1,"%s %s: voltag only makes sense as an element source",
 330                      cname, *argv);
 331
 332         /* <dst2 EU> */
 333         cmd.ce_sdstunit = parse_element_unit(*argv);
 334         ++argv; --argc;
 335
 336  do_special:
 337         /* Deal with optional command modifiers. */
 338         while (argc) {
 339                 val = parse_special(*argv);
 340                 ++argv; --argc;
 341                 switch (val) {
 342                 case SW_INVERT1:
 343                         cmd.ce_flags |= CE_INVERT1;
 344                         break;
 345
 346                 case SW_INVERT2:
 347                         cmd.ce_flags |= CE_INVERT2;
 348                         break;
 349
 350                 default:
 351                         errx(1, "%s: inappropriate modifier `%s'",
 352                             cname, *argv);
 353                         /* NOTREACHED */
 354                 }
 355         }
 356
 357         /* Send command to changer. */
 358         if (ioctl(changer_fd, CHIOEXCHANGE, &cmd))
 359                 err(1, "%s: CHIOEXCHANGE", changer_name);
 360
 361         return (0);
 362
 363  usage:
 364         (void) fprintf(stderr,
 365             "usage: %s %s <src ET> <src EU> <dst1 ET> <dst1 EU>\n"
 366             "       [<dst2 ET> <dst2 EU>] [inv1] [inv2]\n",
 367             __progname, cname);
 368         return (1);
 369 }
 370
 371 static int
 372 do_position(cname, argc, argv)
 373         const char *cname;
 374         int argc;
 375         char **argv;
 376 {
 377         struct changer_position cmd;
 378         int val;
 379
 380         /*
 381          * On a position command, we expect the following:
 382          *
 383          * <to ET> <to EU> [inv]
 384          *
 385          * where ET == element type and EU == element unit.
 386          */
 387
 388         ++argv; --argc;
 389
 390         if (argc < 2) {
 391                 warnx("%s: too few arguments", cname);
 392                 goto usage;
 393         } else if (argc > 3) {
 394                 warnx("%s: too many arguments", cname);
 395                 goto usage;
 396         }
 397         (void) memset(&cmd, 0, sizeof(cmd));
 398
 399         /* <to ET>  */
 400         cmd.cp_type = parse_element_type(*argv);
 401         ++argv; --argc;
 402
 403         /* <to EU> */
 404         cmd.cp_unit = parse_element_unit(*argv);
 405         ++argv; --argc;
 406
 407         /* Deal with optional command modifier. */
 408         if (argc) {
 409                 val = parse_special(*argv);
 410                 switch (val) {
 411                 case SW_INVERT:
 412                         cmd.cp_flags |= CP_INVERT;
 413                         break;
 414
 415                 default:
 416                         errx(1, "%s: inappropriate modifier `%s'",
 417                             cname, *argv);
 418                         /* NOTREACHED */
 419                 }
 420         }
 421
 422         /* Send command to changer. */
 423         if (ioctl(changer_fd, CHIOPOSITION, &cmd))
 424                 err(1, "%s: CHIOPOSITION", changer_name);
 425
 426         return (0);
 427
 428  usage:
 429         (void) fprintf(stderr, "usage: %s %s <to ET> <to EU> [inv]\n",
 430             __progname, cname);
 431         return (1);
 432 }
 433
 434 /* ARGSUSED */
 435 static int
 436 do_params(cname, argc, argv)
 437         const char *cname;
 438         int argc;
 439         char **argv;
 440 {
 441         struct changer_params data;
 442         int picker;
 443
 444         /* No arguments to this command. */
 445
 446         ++argv; --argc;
 447
 448         if (argc) {
 449                 warnx("%s: no arguments expected", cname);
 450                 goto usage;
 451         }
 452
 453         /* Get params from changer and display them. */
 454         (void) memset(&data, 0, sizeof(data));
 455         if (ioctl(changer_fd, CHIOGPARAMS, &data))
 456                 err(1, "%s: CHIOGPARAMS", changer_name);
 457
 458         (void) printf("%s: %d slot%s, %d drive%s, %d picker%s",
 459             changer_name,
 460             data.cp_nslots, (data.cp_nslots > 1) ? "s" : "",
 461             data.cp_ndrives, (data.cp_ndrives > 1) ? "s" : "",
 462             data.cp_npickers, (data.cp_npickers > 1) ? "s" : "");
 463         if (data.cp_nportals)
 464                 (void) printf(", %d portal%s", data.cp_nportals,
 465                     (data.cp_nportals > 1) ? "s" : "");
 466
 467         /* Get current picker from changer and display it. */
 468         if (ioctl(changer_fd, CHIOGPICKER, &picker))
 469                 err(1, "%s: CHIOGPICKER", changer_name);
 470
 471         (void) printf("\n%s: current picker: %d\n", changer_name, picker);
 472
 473         return (0);
 474
 475  usage:
 476         (void) fprintf(stderr, "usage: %s %s\n", __progname, cname);
 477         return (1);
 478 }
 479
 480 /* ARGSUSED */
 481 static int
 482 do_getpicker(cname, argc, argv)
 483         const char *cname;
 484         int argc;
 485         char **argv;
 486 {
 487         int picker;
 488
 489         /* No arguments to this command. */
 490
 491         ++argv; --argc;
 492
 493         if (argc) {
 494                 warnx("%s: no arguments expected", cname);
 495                 goto usage;
 496         }
 497
 498         /* Get current picker from changer and display it. */
 499         if (ioctl(changer_fd, CHIOGPICKER, &picker))
 500                 err(1, "%s: CHIOGPICKER", changer_name);
 501
 502         (void) printf("%s: current picker: %d\n", changer_name, picker);
 503
 504         return (0);
 505
 506  usage:
 507         (void) fprintf(stderr, "usage: %s %s\n", __progname, cname);
 508         return (1);
 509 }
 510
 511 static int
 512 do_setpicker(cname, argc, argv)
 513         const char *cname;
 514         int argc;
 515         char **argv;
 516 {
 517         int picker;
 518
 519         ++argv; --argc;
 520
 521         if (argc < 1) {
 522                 warnx("%s: too few arguments", cname);
 523                 goto usage;
 524         } else if (argc > 1) {
 525                 warnx("%s: too many arguments", cname);
 526                 goto usage;
 527         }
 528
 529         picker = parse_element_unit(*argv);
 530
 531         /* Set the changer picker. */
 532         if (ioctl(changer_fd, CHIOSPICKER, &picker))
 533                 err(1, "%s: CHIOSPICKER", changer_name);
 534
 535         return (0);
 536
 537  usage:
 538         (void) fprintf(stderr, "usage: %s %s <picker>\n", __progname, cname);
 539         return (1);
 540 }
 541
 542 static int
 543 do_status(cname, argc, argv)
 544         const char *cname;
 545         int argc;
 546         char **argv;
 547 {
 548         struct changer_params cp;
 549         struct changer_element_status_request cesr;
 550         int i, count, base, chet, schet, echet;
 551         const char *description;
 552         int pvoltag = 0;
 553         int avoltag = 0;
 554         int sense = 0;
 555         int scsi = 0;
 556         int source = 0;
 557         int intaddr = 0;
 558         int c;
 559
 560         count = 0;
 561         base = 0;
 562         description = NULL;
 563
 564         optind = optreset = 1;
 565         while ((c = getopt(argc, argv, "vVsSbaI")) != -1) {
 566                 switch (c) {
 567                 case 'v':
 568                         pvoltag = 1;
 569                         break;
 570                 case 'V':
 571                         avoltag = 1;
 572                         break;
 573                 case 's':
 574                         sense = 1;
 575                         break;
 576                 case 'S':
 577                         source = 1;
 578                         break;
 579                 case 'b':
 580                         scsi = 1;
 581                         break;
 582                 case 'I':
 583                         intaddr = 1;
 584                         break;
 585                 case 'a':
 586                         pvoltag = avoltag = source = sense = scsi = intaddr = 1;
 587                         break;
 588                 default:
 589                         warnx("%s: bad option", cname);
 590                         goto usage;
 591                 }
 592         }
 593
 594         argc -= optind;
 595         argv += optind;
 596
 597         /*
 598          * On a status command, we expect the following:
 599          *
 600          * [<ET> [<start> [<end>] ] ]
 601          *
 602          * where ET == element type, start == first element to report,
 603          * end == number of elements to report
 604          *
 605          * If we get no arguments, we get the status of all
 606          * known element types.
 607          */
 608         if (argc > 3) {
 609                 warnx("%s: too many arguments", cname);
 610                 goto usage;
 611         }
 612
 613         /*
 614          * Get params from changer.  Specifically, we need the element
 615          * counts.
 616          */
 617         if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
 618                 err(1, "%s: CHIOGPARAMS", changer_name);
 619
 620         if (argc > 0)
 621                 schet = echet = parse_element_type(argv[0]);
 622         else {
 623                 schet = CHET_MT;
 624                 echet = CHET_DT;
 625         }
 626         if (argc > 1) {
 627                 base = atol(argv[1]);
 628                 count = 1;
 629         }
 630         if (argc > 2)
 631                 count = atol(argv[2]) - base + 1;
 632
 633         if (base < 0 || count < 0)
 634                 errx(1, "bad arguments");
 635
 636         for (chet = schet; chet <= echet; ++chet) {
 637                 switch (chet) {
 638                 case CHET_MT:
 639                         if (count == 0)
 640                                 count = cp.cp_npickers;
 641                         else if (count > cp.cp_npickers)
 642                                 errx(1, "not that many pickers in device");
 643                         description = "picker";
 644                         break;
 645
 646                 case CHET_ST:
 647                         if (count == 0)
 648                                 count = cp.cp_nslots;
 649                         else if (count > cp.cp_nslots)
 650                                 errx(1, "not that many slots in device");
 651                         description = "slot";
 652                         break;
 653
 654                 case CHET_IE:
 655                         if (count == 0)
 656                                 count = cp.cp_nportals;
 657                         else if (count > cp.cp_nportals)
 658                                 errx(1, "not that many portals in device");
 659                         description = "portal";
 660                         break;
 661
 662                 case CHET_DT:
 663                         if (count == 0)
 664                                 count = cp.cp_ndrives;
 665                         else if (count > cp.cp_ndrives)
 666                                 errx(1, "not that many drives in device");
 667                         description = "drive";
 668                         break;
 669
 670                 default:
 671                         /* To appease gcc -Wuninitialized. */
 672                         count = 0;
 673                         description = NULL;
 674                 }
 675
 676                 if (count == 0) {
 677                         if (argc == 0)
 678                                 continue;
 679                         else {
 680                                 printf("%s: no %s elements\n",
 681                                     changer_name, description);
 682                                 return (0);
 683                         }
 684                 }
 685
 686                 bzero(&cesr, sizeof(cesr));
 687                 cesr.cesr_element_type = chet;
 688                 cesr.cesr_element_base = base;
 689                 cesr.cesr_element_count = count;
 690                 /* Allocate storage for the status structures. */
 691                 cesr.cesr_element_status =
 692                   (struct changer_element_status *)
 693                   calloc((size_t)count, sizeof(struct changer_element_status));
 694
 695                 if (!cesr.cesr_element_status)
 696                         errx(1, "can't allocate status storage");
 697
 698                 if (avoltag || pvoltag)
 699                         cesr.cesr_flags |= CESR_VOLTAGS;
 700
 701                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr)) {
 702                         free(cesr.cesr_element_status);
 703                         err(1, "%s: CHIOGSTATUS", changer_name);
 704                 }
 705
 706                 /* Dump the status for each reported element. */
 707                 for (i = 0; i < count; ++i) {
 708                         struct changer_element_status *ces =
 709                                  &(cesr.cesr_element_status[i]);
 710                         printf("%s %d: %s", description, ces->ces_addr,
 711                             bits_to_string(ces->ces_flags,
 712                                            CESTATUS_BITS));
 713                         if (sense)
 714                                 printf(" sense: <0x%02x/0x%02x>",
 715                                        ces->ces_sensecode,
 716                                        ces->ces_sensequal);
 717                         if (pvoltag)
 718                                 printf(" voltag: <%s:%d>",
 719                                        ces->ces_pvoltag.cv_volid,
 720                                        ces->ces_pvoltag.cv_serial);
 721                         if (avoltag)
 722                                 printf(" avoltag: <%s:%d>",
 723                                        ces->ces_avoltag.cv_volid,
 724                                        ces->ces_avoltag.cv_serial);
 725                         if (source) {
 726                                 if (ces->ces_flags & CES_SOURCE_VALID)
 727                                         printf(" source: <%s %d>",
 728                                                element_type_name(
 729                                                        ces->ces_source_type),
 730                                                ces->ces_source_addr);
 731                                 else
 732                                         printf(" source: <>");
 733                         }
 734                         if (intaddr)
 735                                 printf(" intaddr: <%d>", ces->ces_int_addr);
 736                         if (scsi) {
 737                                 printf(" scsi: <");
 738                                 if (ces->ces_flags & CES_SCSIID_VALID)
 739                                         printf("%d", ces->ces_scsi_id);
 740                                 else
 741                                         putchar('?');
 742                                 putchar(':');
 743                                 if (ces->ces_flags & CES_LUN_VALID)
 744                                         printf("%d", ces->ces_scsi_lun);
 745                                 else
 746                                         putchar('?');
 747                                 putchar('>');
 748                         }
 749                         putchar('\n');
 750                 }
 751
 752                 free(cesr.cesr_element_status);
 753                 count = 0;
 754         }
 755
 756         return (0);
 757
 758  usage:
 759         (void) fprintf(stderr, "usage: %s %s [-vVsSbaA] [<element type> [<start-addr> [<end-addr>] ] ]\n",
 760                        __progname, cname);
 761         return (1);
 762 }
 763
 764 static int
 765 do_ielem(cname, argc, argv)
 766         const char *cname;
 767         int argc;
 768         char **argv;
 769 {
 770         int timeout = 0;
 771
 772         if (argc == 2) {
 773                 timeout = atol(argv[1]);
 774         } else if (argc > 1) {
 775                 warnx("%s: too many arguments", cname);
 776                 goto usage;
 777         }
 778
 779         if (ioctl(changer_fd, CHIOIELEM, &timeout))
 780                 err(1, "%s: CHIOIELEM", changer_name);
 781
 782         return (0);
 783
 784  usage:
 785         (void) fprintf(stderr, "usage: %s %s [<timeout>]\n",
 786                        __progname, cname);
 787         return (1);
 788 }
 789
 790 static int
 791 do_voltag(cname, argc, argv)
 792         const char *cname;
 793         int argc;
 794         char **argv;
 795 {
 796         int force = 0;
 797         int clear = 0;
 798         int alternate = 0;
 799         int c;
 800         struct changer_set_voltag_request csvr;
 801
 802         bzero(&csvr, sizeof(csvr));
 803
 804         optind = optreset = 1;
 805         while ((c = getopt(argc, argv, "fca")) != -1) {
 806                 switch (c) {
 807                 case 'f':
 808                         force = 1;
 809                         break;
 810                 case 'c':
 811                         clear = 1;
 812                         break;
 813                 case 'a':
 814                         alternate = 1;
 815                         break;
 816                 default:
 817                         warnx("%s: bad option", cname);
 818                         goto usage;
 819                 }
 820         }
 821
 822         argc -= optind;
 823         argv += optind;
 824
 825         if (argc < 2) {
 826                 warnx("%s: missing element specification", cname);
 827                 goto usage;
 828         }
 829
 830         csvr.csvr_type = parse_element_type(argv[0]);
 831         csvr.csvr_addr = atol(argv[1]);
 832
 833         if (!clear) {
 834                 if (argc < 3 || argc > 4) {
 835                         warnx("%s: missing argument", cname);
 836                         goto usage;
 837                 }
 838
 839                 if (force)
 840                         csvr.csvr_flags = CSVR_MODE_REPLACE;
 841                 else
 842                         csvr.csvr_flags = CSVR_MODE_SET;
 843
 844                 if (strlen(argv[2]) > sizeof(csvr.csvr_voltag.cv_volid)) {
 845                         warnx("%s: volume label too long", cname);
 846                         goto usage;
 847                 }
 848
 849                 strlcpy((char *)csvr.csvr_voltag.cv_volid, argv[2],
 850                        sizeof(csvr.csvr_voltag.cv_volid));
 851
 852                 if (argc == 4) {
 853                         csvr.csvr_voltag.cv_serial = atol(argv[3]);
 854                 }
 855         } else {
 856                 if (argc != 2) {
 857                         warnx("%s: unexpected argument", cname);
 858                         goto usage;
 859                 }
 860                 csvr.csvr_flags = CSVR_MODE_CLEAR;
 861         }
 862
 863         if (alternate) {
 864                 csvr.csvr_flags |= CSVR_ALTERNATE;
 865         }
 866
 867         if (ioctl(changer_fd, CHIOSETVOLTAG, &csvr))
 868                 err(1, "%s: CHIOSETVOLTAG", changer_name);
 869
 870         return 0;
 871  usage:
 872         (void) fprintf(stderr,
 873                        "usage: %s %s [-fca] <element> [<voltag> [<vsn>] ]\n",
 874                        __progname, cname);
 875         return 1;
 876 }
 877
 878 static int
 879 parse_element_type(cp)
 880         char *cp;
 881 {
 882         int i;
 883
 884         for (i = 0; elements[i].et_name != NULL; ++i)
 885                 if (strcmp(elements[i].et_name, cp) == 0)
 886                         return (elements[i].et_type);
 887
 888         errx(1, "invalid element type `%s'", cp);
 889         /* NOTREACHED */
 890 }
 891
 892 static const char *
 893 element_type_name(et)
 894         int et;
 895 {
 896         int i;
 897
 898         for (i = 0; elements[i].et_name != NULL; i++)
 899                 if (elements[i].et_type == et)
 900                         return elements[i].et_name;
 901
 902         return "unknown";
 903 }
 904
 905 static int
 906 parse_element_unit(cp)
 907         char *cp;
 908 {
 909         int i;
 910         char *p;
 911
 912         i = (int)strtol(cp, &p, 10);
 913         if ((i < 0) || (*p != '\0'))
 914                 errx(1, "invalid unit number `%s'", cp);
 915
 916         return (i);
 917 }
 918
 919 static int
 920 parse_special(cp)
 921         char *cp;
 922 {
 923         int val;
 924
 925         val = is_special(cp);
 926         if (val)
 927                 return (val);
 928
 929         errx(1, "invalid modifier `%s'", cp);
 930         /* NOTREACHED */
 931 }
 932
 933 static int
 934 is_special(cp)
 935         char *cp;
 936 {
 937         int i;
 938
 939         for (i = 0; specials[i].sw_name != NULL; ++i)
 940                 if (strcmp(specials[i].sw_name, cp) == 0)
 941                         return (specials[i].sw_value);
 942
 943         return (0);
 944 }
 945
 946 static const char *
 947 bits_to_string(v, cp)
 948         ces_status_flags v;
 949         const char *cp;
 950 {
 951         const char *np;
 952         char f, sep, *bp;
 953         static char buf[128];
 954
 955         bp = buf;
 956         (void) memset(buf, 0, sizeof(buf));
 957
 958         for (sep = '<'; (f = *cp++) != 0; cp = np) {
 959                 for (np = cp; *np >= ' ';)
 960                         np++;
 961                 if ((v & (1 << (f - 1))) == 0)
 962                         continue;
 963                 (void) snprintf(bp, sizeof(buf) - (bp - &buf[0]),
 964                         "%c%.*s", sep, (int)(long)(np - cp), cp);
 965                 bp += strlen(bp);
 966                 sep = ',';
 967         }
 968         if (sep != '<')
 969                 *bp = '>';
 970
 971         return (buf);
 972 }
 973 /*
 974  * do_return()
 975  *
 976  * Given an element reference, ask the changer/picker to move that
 977  * element back to its source slot.
 978  */
 979 static int
 980 do_return(cname, argc, argv)
 981         const char *cname;
 982         int  argc;
 983         char **argv;
 984 {
 985         struct changer_element_status *ces;
 986         struct changer_move cmd;
 987         u_int16_t       type, element;
 988
 989         ++argv; --argc;
 990
 991         if (argc < 2) {
 992                 warnx("%s: too few arguments", cname);
 993                 goto usage;
 994         } else if (argc > 3) {
 995                 warnx("%s: too many arguments", cname);
 996                 goto usage;
 997         }
 998
 999         type = parse_element_type(*argv);
1000         ++argv; --argc;
1001
1002         /* Handle voltag virtual Changer Element Type */
1003         if (CHET_VT == type) {
1004                 find_element(*argv, &type, &element);
1005         } else {
1006                 element = parse_element_unit(*argv);
1007         }
1008         ++argv; --argc;
1009
1010         /* Get the status */
1011         ces = get_element_status((unsigned int)type, (unsigned int)element);
1012
1013         if (NULL == ces)
1014                 errx(1, "%s: null element status pointer", cname);
1015
1016         if (!(ces->ces_flags & CES_SOURCE_VALID))
1017                 errx(1, "%s: no source information", cname);
1018
1019         (void) memset(&cmd, 0, sizeof(cmd));
1020
1021         cmd.cm_fromtype = type;
1022         cmd.cm_fromunit = element;
1023         cmd.cm_totype = ces->ces_source_type;
1024         cmd.cm_tounit = ces->ces_source_addr;
1025
1026         if (ioctl(changer_fd, CHIOMOVE, &cmd) == -1)
1027                 err(1, "%s: CHIOMOVE", changer_name);
1028         free(ces);
1029
1030         return(0);
1031
1032 usage:
1033         (void) fprintf(stderr, "usage: %s %s "
1034             "<from ET> <from EU>\n", __progname, cname);
1035         return(1);
1036 }
1037
1038 /*
1039  * get_element_status()
1040  *
1041  * return a *cesr for the specified changer element.  This
1042  * routing will malloc()/calloc() the memory.  The caller
1043  * should free() it when done.
1044  */
1045 static struct changer_element_status *
1046 get_element_status(type, element)
1047         unsigned int    type;
1048         unsigned int    element;
1049 {
1050         struct changer_element_status_request cesr;
1051         struct changer_element_status *ces;
1052
1053         ces = (struct changer_element_status *)
1054             calloc((size_t)1, sizeof(struct changer_element_status));
1055
1056         if (NULL == ces)
1057                 errx(1, "can't allocate status storage");
1058
1059         (void)memset(&cesr, 0, sizeof(cesr));
1060
1061         cesr.cesr_element_type = (u_int16_t)type;
1062         cesr.cesr_element_base = (u_int16_t)element;
1063         cesr.cesr_element_count = 1;            /* Only this one element */
1064         cesr.cesr_flags |= CESR_VOLTAGS;        /* Grab voltags as well */
1065         cesr.cesr_element_status = ces;
1066
1067         if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1068                 free(ces);
1069                 err(1, "%s: CHIOGSTATUS", changer_name);
1070                 /* NOTREACHED */
1071         }
1072
1073         return ces;
1074 }
1075
1076
1077 /*
1078  * find_element()
1079  *
1080  * Given a <voltag> find the chager element and unit, or exit
1081  * with an error if it isn't found.  We grab the changer status
1082  * and iterate until we find a match, or crap out.
1083  */
1084 static void
1085 find_element(voltag, et, eu)
1086         char *voltag;
1087         u_int16_t *et;
1088         u_int16_t *eu;
1089 {
1090         struct changer_params cp;
1091         struct changer_element_status_request cesr;
1092         struct changer_element_status *ch_ces, *ces;
1093         int found = 0;
1094         size_t elem, total_elem;
1095
1096         /*
1097          * Get the changer parameters, we're interested in the counts
1098          * for all types of elements to perform our search.
1099          */
1100         if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
1101                 err(1, "%s: CHIOGPARAMS", changer_name);
1102
1103         /* Allocate some memory for the results */
1104         total_elem = (cp.cp_nslots + cp.cp_ndrives
1105             + cp.cp_npickers + cp.cp_nportals);
1106
1107         ch_ces = (struct changer_element_status *)
1108             calloc(total_elem, sizeof(struct changer_element_status));
1109
1110         if (NULL == ch_ces)
1111                 errx(1, "can't allocate status storage");
1112
1113         ces = ch_ces;
1114
1115         /* Read in the changer slots */
1116         if (cp.cp_nslots > 0) {
1117                 cesr.cesr_element_type = CHET_ST;
1118                 cesr.cesr_element_base = 0;
1119                 cesr.cesr_element_count = cp.cp_nslots;
1120                 cesr.cesr_flags |= CESR_VOLTAGS;
1121                 cesr.cesr_element_status = ces;
1122
1123                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1124                         free(ch_ces);
1125                         err(1, "%s: CHIOGSTATUS", changer_name);
1126                 }
1127                 ces += cp.cp_nslots;
1128         }
1129
1130         /* Read in the drive information */
1131         if (cp.cp_ndrives > 0 ) {
1132
1133                 (void) memset(&cesr, 0, sizeof(cesr));
1134                 cesr.cesr_element_type = CHET_DT;
1135                 cesr.cesr_element_base = 0;
1136                 cesr.cesr_element_count = cp.cp_ndrives;
1137                 cesr.cesr_flags |= CESR_VOLTAGS;
1138                 cesr.cesr_element_status = ces;
1139
1140                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1141                         free(ch_ces);
1142                         err(1, "%s: CHIOGSTATUS", changer_name);
1143                 }
1144                 ces += cp.cp_ndrives;
1145         }
1146
1147         /* Read in the portal information */
1148         if (cp.cp_nportals > 0 ) {
1149                 (void) memset(&cesr, 0, sizeof(cesr));
1150                 cesr.cesr_element_type = CHET_IE;
1151                 cesr.cesr_element_base = 0;
1152                 cesr.cesr_element_count = cp.cp_nportals;
1153                 cesr.cesr_flags |= CESR_VOLTAGS;
1154                 cesr.cesr_element_status = ces;
1155
1156                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1157                         free(ch_ces);
1158                         err(1, "%s: CHIOGSTATUS", changer_name);
1159                 }
1160                 ces += cp.cp_nportals;
1161         }
1162
1163         /* Read in the picker information */
1164         if (cp.cp_npickers > 0) {
1165                 (void) memset(&cesr, 0, sizeof(cesr));
1166                 cesr.cesr_element_type = CHET_MT;
1167                 cesr.cesr_element_base = 0;
1168                 cesr.cesr_element_count = cp.cp_npickers;
1169                 cesr.cesr_flags |= CESR_VOLTAGS;
1170                 cesr.cesr_element_status = ces;
1171
1172                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1173                         free(ch_ces);
1174                         err(1, "%s: CHIOGSTATUS", changer_name);
1175                 }
1176         }
1177
1178         /*
1179          * Now search the list the specified <voltag>
1180          */
1181         for (elem = 0; elem <= total_elem; ++elem) {
1182
1183                 ces = &ch_ces[elem];
1184
1185                 /* Make sure we have a tape in this element */
1186                 if ((ces->ces_flags & (CES_STATUS_ACCESS|CES_STATUS_FULL))
1187                     != (CES_STATUS_ACCESS|CES_STATUS_FULL))
1188                         continue;
1189
1190                 /* Check to see if it is our target */
1191                 if (strcasecmp(voltag,
1192                     (const char *)ces->ces_pvoltag.cv_volid) == 0) {
1193                         *et = ces->ces_type;
1194                         *eu = ces->ces_addr;
1195                         ++found;
1196                         break;
1197                 }
1198         }
1199         if (!found) {
1200                 errx(1, "%s: unable to locate voltag: %s", changer_name,
1201                      voltag);
1202         }
1203         free(ch_ces);
1204         return;
1205 }
1206
1207 static void
1208 cleanup()
1209 {
1210         /* Simple enough... */
1211         (void)close(changer_fd);
1212 }
1213
1214 static void
1215 usage()
1216 {
1217         (void) fprintf(stderr, "usage: %s [-f changer] command [-<flags>] "
1218                 "arg1 arg2 [arg3 [...]]\n", __progname);
1219         exit(1);
1220 }