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