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