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 * Additional Copyright (c) 2000, by C. Stephen Gunn, Waterspout Communications
36 */
37
38 #include <sys/param.h>
39 #include <sys/chio.h>
40 #include <err.h>
41 #include <fcntl.h>
42 #include <stdio.h>
43 #include <stdint.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <langinfo.h>
48 #include <locale.h>
49
50 #include "defs.h"
51 #include "pathnames.h"
52
53 static void usage(void) __dead2;
54 static void cleanup(void);
55 static u_int16_t parse_element_type(char *);
56 static u_int16_t parse_element_unit(char *);
57 static const char * element_type_name(int et);
58 static int parse_special(char *);
59 static int is_special(char *);
60 static const char *bits_to_string(ces_status_flags, const char *);
61
62 static void find_element(char *, uint16_t *, uint16_t *);
63 static struct changer_element_status *get_element_status
64 (unsigned int, unsigned int, int);
65
66 static int do_move(const char *, int, char **);
67 static int do_exchange(const char *, int, char **);
68 static int do_position(const char *, int, char **);
69 static int do_params(const char *, int, char **);
70 static int do_getpicker(const char *, int, char **);
71 static int do_setpicker(const char *, int, char **);
72 static int do_status(const char *, int, char **);
73 static int do_ielem(const char *, int, char **);
74 static int do_return(const char *, int, char **);
75 static int do_voltag(const char *, int, char **);
76 static void print_designator(const char *, u_int8_t, u_int8_t);
77
78 #ifndef CHET_VT
79 #define CHET_VT 10 /* Completely Arbitrary */
80 #endif
81
82 /* Valid changer element types. */
83 static const struct element_type elements[] = {
84 { "drive", CHET_DT },
85 { "picker", CHET_MT },
86 { "portal", CHET_IE },
87 { "slot", CHET_ST },
88 { "voltag", CHET_VT }, /* Select tapes by barcode */
89 { NULL, 0 },
90 };
91
92 /* Valid commands. */
93 static const struct changer_command commands[] = {
94 { "exchange", do_exchange },
95 { "getpicker", do_getpicker },
96 { "ielem", do_ielem },
97 { "move", do_move },
98 { "params", do_params },
99 { "position", do_position },
100 { "setpicker", do_setpicker },
101 { "status", do_status },
102 { "return", do_return },
103 { "voltag", do_voltag },
104 { NULL, 0 },
105 };
106
107 /* Valid special words. */
108 static const struct special_word specials[] = {
109 { "inv", SW_INVERT },
110 { "inv1", SW_INVERT1 },
111 { "inv2", SW_INVERT2 },
112 { NULL, 0 },
113 };
114
115 static int changer_fd;
116 static const char *changer_name;
117
118 int
main(int argc,char ** argv)119 main(int argc, char **argv)
120 {
121 int ch, i;
122
123 while ((ch = getopt(argc, argv, "f:")) != -1) {
124 switch (ch) {
125 case 'f':
126 changer_name = optarg;
127 break;
128
129 default:
130 usage();
131 }
132 }
133 argc -= optind;
134 argv += optind;
135
136 if (argc == 0)
137 usage();
138
139 /* Get the default changer if not already specified. */
140 if (changer_name == NULL)
141 if ((changer_name = getenv(CHANGER_ENV_VAR)) == NULL)
142 changer_name = _PATH_CH;
143
144 /* Open the changer device. */
145 if ((changer_fd = open(changer_name, O_RDWR, 0600)) == -1)
146 err(1, "%s: open", changer_name);
147
148 /* Register cleanup function. */
149 if (atexit(cleanup))
150 err(1, "can't register cleanup function");
151
152 /* Find the specified command. */
153 for (i = 0; commands[i].cc_name != NULL; ++i)
154 if (strcmp(*argv, commands[i].cc_name) == 0)
155 break;
156 if (commands[i].cc_name == NULL) {
157 /* look for abbreviation */
158 for (i = 0; commands[i].cc_name != NULL; ++i)
159 if (strncmp(*argv, commands[i].cc_name,
160 strlen(*argv)) == 0)
161 break;
162 }
163
164 if (commands[i].cc_name == NULL)
165 errx(1, "unknown command: %s", *argv);
166
167 exit ((*commands[i].cc_handler)(commands[i].cc_name, argc, argv));
168 /* NOTREACHED */
169 }
170
171 static int
do_move(const char * cname,int argc,char ** argv)172 do_move(const char *cname, int argc, char **argv)
173 {
174 struct changer_move cmd;
175 int val;
176
177 /*
178 * On a move command, we expect the following:
179 *
180 * <from ET> <from EU> <to ET> <to EU> [inv]
181 *
182 * where ET == element type and EU == element unit.
183 */
184
185 ++argv; --argc;
186
187 if (argc < 4) {
188 warnx("%s: too few arguments", cname);
189 goto usage;
190 } else if (argc > 5) {
191 warnx("%s: too many arguments", cname);
192 goto usage;
193 }
194 (void) memset(&cmd, 0, sizeof(cmd));
195
196 /* <from ET> */
197 cmd.cm_fromtype = parse_element_type(*argv);
198 ++argv; --argc;
199
200 /* Check for voltag virtual type */
201 if (CHET_VT == cmd.cm_fromtype) {
202 find_element(*argv, &cmd.cm_fromtype, &cmd.cm_fromunit);
203 } else {
204 /* <from EU> */
205 cmd.cm_fromunit = parse_element_unit(*argv);
206 }
207 ++argv; --argc;
208
209 /* <to ET> */
210 cmd.cm_totype = parse_element_type(*argv);
211 ++argv; --argc;
212
213 /* Check for voltag virtual type, and report error */
214 if (CHET_VT == cmd.cm_totype)
215 errx(1,"%s: voltag only makes sense as an element source",
216 cname);
217
218 /* <to EU> */
219 cmd.cm_tounit = parse_element_unit(*argv);
220 ++argv; --argc;
221
222 /* Deal with optional command modifier. */
223 if (argc) {
224 val = parse_special(*argv);
225 switch (val) {
226 case SW_INVERT:
227 cmd.cm_flags |= CM_INVERT;
228 break;
229
230 default:
231 errx(1, "%s: inappropriate modifier `%s'",
232 cname, *argv);
233 /* NOTREACHED */
234 }
235 }
236
237 /* Send command to changer. */
238 if (ioctl(changer_fd, CHIOMOVE, &cmd))
239 err(1, "%s: CHIOMOVE", changer_name);
240
241 return (0);
242
243 usage:
244 (void) fprintf(stderr, "usage: %s %s "
245 "<from ET> <from EU> <to ET> <to EU> [inv]\n", getprogname(), cname);
246 return (1);
247 }
248
249 static int
do_exchange(const char * cname,int argc,char ** argv)250 do_exchange(const char *cname, int argc, char **argv)
251 {
252 struct changer_exchange cmd;
253 int val;
254
255 /*
256 * On an exchange command, we expect the following:
257 *
258 * <src ET> <src EU> <dst1 ET> <dst1 EU> [<dst2 ET> <dst2 EU>] [inv1] [inv2]
259 *
260 * where ET == element type and EU == element unit.
261 */
262
263 ++argv; --argc;
264
265 if (argc < 4) {
266 warnx("%s: too few arguments", cname);
267 goto usage;
268 } else if (argc > 8) {
269 warnx("%s: too many arguments", cname);
270 goto usage;
271 }
272 (void) memset(&cmd, 0, sizeof(cmd));
273
274 /* <src ET> */
275 cmd.ce_srctype = parse_element_type(*argv);
276 ++argv; --argc;
277
278 /* Check for voltag virtual type */
279 if (CHET_VT == cmd.ce_srctype) {
280 find_element(*argv, &cmd.ce_srctype, &cmd.ce_srcunit);
281 } else {
282 /* <from EU> */
283 cmd.ce_srcunit = parse_element_unit(*argv);
284 }
285 ++argv; --argc;
286
287 /* <dst1 ET> */
288 cmd.ce_fdsttype = parse_element_type(*argv);
289 ++argv; --argc;
290
291 /* Check for voltag virtual type */
292 if (CHET_VT == cmd.ce_fdsttype) {
293 find_element(*argv, &cmd.ce_fdsttype, &cmd.ce_fdstunit);
294 } else {
295 /* <from EU> */
296 cmd.ce_fdstunit = parse_element_unit(*argv);
297 }
298 ++argv; --argc;
299
300 /*
301 * If the next token is a special word or there are no more
302 * arguments, then this is a case of simple exchange.
303 * dst2 == src.
304 */
305 if ((argc == 0) || is_special(*argv)) {
306 cmd.ce_sdsttype = cmd.ce_srctype;
307 cmd.ce_sdstunit = cmd.ce_srcunit;
308 goto do_special;
309 }
310
311 /* <dst2 ET> */
312 cmd.ce_sdsttype = parse_element_type(*argv);
313 ++argv; --argc;
314
315 if (CHET_VT == cmd.ce_sdsttype)
316 errx(1,"%s %s: voltag only makes sense as an element source",
317 cname, *argv);
318
319 /* <dst2 EU> */
320 cmd.ce_sdstunit = parse_element_unit(*argv);
321 ++argv; --argc;
322
323 do_special:
324 /* Deal with optional command modifiers. */
325 while (argc) {
326 val = parse_special(*argv);
327 ++argv; --argc;
328 switch (val) {
329 case SW_INVERT1:
330 cmd.ce_flags |= CE_INVERT1;
331 break;
332
333 case SW_INVERT2:
334 cmd.ce_flags |= CE_INVERT2;
335 break;
336
337 default:
338 errx(1, "%s: inappropriate modifier `%s'",
339 cname, *argv);
340 /* NOTREACHED */
341 }
342 }
343
344 /* Send command to changer. */
345 if (ioctl(changer_fd, CHIOEXCHANGE, &cmd))
346 err(1, "%s: CHIOEXCHANGE", changer_name);
347
348 return (0);
349
350 usage:
351 (void) fprintf(stderr,
352 "usage: %s %s <src ET> <src EU> <dst1 ET> <dst1 EU>\n"
353 " [<dst2 ET> <dst2 EU>] [inv1] [inv2]\n",
354 getprogname(), cname);
355 return (1);
356 }
357
358 static int
do_position(const char * cname,int argc,char ** argv)359 do_position(const char *cname, int argc, char **argv)
360 {
361 struct changer_position cmd;
362 int val;
363
364 /*
365 * On a position command, we expect the following:
366 *
367 * <to ET> <to EU> [inv]
368 *
369 * where ET == element type and EU == element unit.
370 */
371
372 ++argv; --argc;
373
374 if (argc < 2) {
375 warnx("%s: too few arguments", cname);
376 goto usage;
377 } else if (argc > 3) {
378 warnx("%s: too many arguments", cname);
379 goto usage;
380 }
381 (void) memset(&cmd, 0, sizeof(cmd));
382
383 /* <to ET> */
384 cmd.cp_type = parse_element_type(*argv);
385 ++argv; --argc;
386
387 /* <to EU> */
388 cmd.cp_unit = parse_element_unit(*argv);
389 ++argv; --argc;
390
391 /* Deal with optional command modifier. */
392 if (argc) {
393 val = parse_special(*argv);
394 switch (val) {
395 case SW_INVERT:
396 cmd.cp_flags |= CP_INVERT;
397 break;
398
399 default:
400 errx(1, "%s: inappropriate modifier `%s'",
401 cname, *argv);
402 /* NOTREACHED */
403 }
404 }
405
406 /* Send command to changer. */
407 if (ioctl(changer_fd, CHIOPOSITION, &cmd))
408 err(1, "%s: CHIOPOSITION", changer_name);
409
410 return (0);
411
412 usage:
413 (void) fprintf(stderr, "usage: %s %s <to ET> <to EU> [inv]\n",
414 getprogname(), cname);
415 return (1);
416 }
417
418 /* ARGSUSED */
419 static int
do_params(const char * cname,int argc,char ** argv __unused)420 do_params(const char *cname, int argc, char **argv __unused)
421 {
422 struct changer_params data;
423 int picker;
424
425 /* No arguments to this command. */
426
427 ++argv; --argc;
428
429 if (argc) {
430 warnx("%s: no arguments expected", cname);
431 goto usage;
432 }
433
434 /* Get params from changer and display them. */
435 (void) memset(&data, 0, sizeof(data));
436 if (ioctl(changer_fd, CHIOGPARAMS, &data))
437 err(1, "%s: CHIOGPARAMS", changer_name);
438
439 (void) printf("%s: %d slot%s, %d drive%s, %d picker%s",
440 changer_name,
441 data.cp_nslots, (data.cp_nslots > 1) ? "s" : "",
442 data.cp_ndrives, (data.cp_ndrives > 1) ? "s" : "",
443 data.cp_npickers, (data.cp_npickers > 1) ? "s" : "");
444 if (data.cp_nportals)
445 (void) printf(", %d portal%s", data.cp_nportals,
446 (data.cp_nportals > 1) ? "s" : "");
447
448 /* Get current picker from changer and display it. */
449 if (ioctl(changer_fd, CHIOGPICKER, &picker))
450 err(1, "%s: CHIOGPICKER", changer_name);
451
452 (void) printf("\n%s: current picker: %d\n", changer_name, picker);
453
454 return (0);
455
456 usage:
457 (void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
458 return (1);
459 }
460
461 /* ARGSUSED */
462 static int
do_getpicker(const char * cname,int argc,char ** argv __unused)463 do_getpicker(const char *cname, int argc, char **argv __unused)
464 {
465 int picker;
466
467 /* No arguments to this command. */
468
469 ++argv; --argc;
470
471 if (argc) {
472 warnx("%s: no arguments expected", cname);
473 goto usage;
474 }
475
476 /* Get current picker from changer and display it. */
477 if (ioctl(changer_fd, CHIOGPICKER, &picker))
478 err(1, "%s: CHIOGPICKER", changer_name);
479
480 (void) printf("%s: current picker: %d\n", changer_name, picker);
481
482 return (0);
483
484 usage:
485 (void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
486 return (1);
487 }
488
489 static int
do_setpicker(const char * cname,int argc,char ** argv)490 do_setpicker(const char *cname, int argc, char **argv)
491 {
492 int picker;
493
494 ++argv; --argc;
495
496 if (argc < 1) {
497 warnx("%s: too few arguments", cname);
498 goto usage;
499 } else if (argc > 1) {
500 warnx("%s: too many arguments", cname);
501 goto usage;
502 }
503
504 picker = parse_element_unit(*argv);
505
506 /* Set the changer picker. */
507 if (ioctl(changer_fd, CHIOSPICKER, &picker))
508 err(1, "%s: CHIOSPICKER", changer_name);
509
510 return (0);
511
512 usage:
513 (void) fprintf(stderr, "usage: %s %s <picker>\n", getprogname(), cname);
514 return (1);
515 }
516
517 static int
do_status(const char * cname,int argc,char ** argv)518 do_status(const char *cname, int argc, char **argv)
519 {
520 struct changer_params cp;
521 struct changer_element_status_request cesr;
522 int i;
523 u_int16_t base, count, chet, schet, echet;
524 const char *description;
525 int pvoltag = 0;
526 int avoltag = 0;
527 int sense = 0;
528 int scsi = 0;
529 int source = 0;
530 int intaddr = 0;
531 int c;
532
533 count = 0;
534 base = 0;
535 description = NULL;
536
537 optind = optreset = 1;
538 while ((c = getopt(argc, argv, "vVsSbaI")) != -1) {
539 switch (c) {
540 case 'v':
541 pvoltag = 1;
542 break;
543 case 'V':
544 avoltag = 1;
545 break;
546 case 's':
547 sense = 1;
548 break;
549 case 'S':
550 source = 1;
551 break;
552 case 'b':
553 scsi = 1;
554 break;
555 case 'I':
556 intaddr = 1;
557 break;
558 case 'a':
559 pvoltag = avoltag = source = sense = scsi = intaddr = 1;
560 break;
561 default:
562 warnx("%s: bad option", cname);
563 goto usage;
564 }
565 }
566
567 argc -= optind;
568 argv += optind;
569
570 /*
571 * On a status command, we expect the following:
572 *
573 * [<ET> [<start> [<end>] ] ]
574 *
575 * where ET == element type, start == first element to report,
576 * end == number of elements to report
577 *
578 * If we get no arguments, we get the status of all
579 * known element types.
580 */
581 if (argc > 3) {
582 warnx("%s: too many arguments", cname);
583 goto usage;
584 }
585
586 /*
587 * Get params from changer. Specifically, we need the element
588 * counts.
589 */
590 if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
591 err(1, "%s: CHIOGPARAMS", changer_name);
592
593 if (argc > 0)
594 schet = echet = parse_element_type(argv[0]);
595 else {
596 schet = CHET_MT;
597 echet = CHET_DT;
598 }
599 if (argc > 1) {
600 base = (u_int16_t)atol(argv[1]);
601 count = 1;
602 }
603 if (argc > 2)
604 count = (u_int16_t)atol(argv[2]) - base + 1;
605
606 for (chet = schet; chet <= echet; ++chet) {
607 switch (chet) {
608 case CHET_MT:
609 if (count == 0)
610 count = cp.cp_npickers;
611 else if (count > cp.cp_npickers)
612 errx(1, "not that many pickers in device");
613 description = "picker";
614 break;
615
616 case CHET_ST:
617 if (count == 0)
618 count = cp.cp_nslots;
619 else if (count > cp.cp_nslots)
620 errx(1, "not that many slots in device");
621 description = "slot";
622 break;
623
624 case CHET_IE:
625 if (count == 0)
626 count = cp.cp_nportals;
627 else if (count > cp.cp_nportals)
628 errx(1, "not that many portals in device");
629 description = "portal";
630 break;
631
632 case CHET_DT:
633 if (count == 0)
634 count = cp.cp_ndrives;
635 else if (count > cp.cp_ndrives)
636 errx(1, "not that many drives in device");
637 description = "drive";
638 break;
639
640 default:
641 /* To appease gcc -Wuninitialized. */
642 count = 0;
643 description = NULL;
644 }
645
646 if (count == 0) {
647 if (argc == 0)
648 continue;
649 else {
650 printf("%s: no %s elements\n",
651 changer_name, description);
652 return (0);
653 }
654 }
655
656 bzero(&cesr, sizeof(cesr));
657 cesr.cesr_element_type = chet;
658 cesr.cesr_element_base = base;
659 cesr.cesr_element_count = count;
660 /* Allocate storage for the status structures. */
661 cesr.cesr_element_status =
662 (struct changer_element_status *)
663 calloc((size_t)count, sizeof(struct changer_element_status));
664
665 if (!cesr.cesr_element_status)
666 errx(1, "can't allocate status storage");
667
668 if (avoltag || pvoltag)
669 cesr.cesr_flags |= CESR_VOLTAGS;
670
671 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr)) {
672 free(cesr.cesr_element_status);
673 err(1, "%s: CHIOGSTATUS", changer_name);
674 }
675
676 /* Dump the status for each reported element. */
677 for (i = 0; i < count; ++i) {
678 struct changer_element_status *ces =
679 &(cesr.cesr_element_status[i]);
680 printf("%s %d: %s", description, ces->ces_addr,
681 bits_to_string(ces->ces_flags,
682 CESTATUS_BITS));
683 if (sense)
684 printf(" sense: <0x%02x/0x%02x>",
685 ces->ces_sensecode,
686 ces->ces_sensequal);
687 if (pvoltag)
688 printf(" voltag: <%s:%d>",
689 ces->ces_pvoltag.cv_volid,
690 ces->ces_pvoltag.cv_serial);
691 if (avoltag)
692 printf(" avoltag: <%s:%d>",
693 ces->ces_avoltag.cv_volid,
694 ces->ces_avoltag.cv_serial);
695 if (source) {
696 if (ces->ces_flags & CES_SOURCE_VALID)
697 printf(" source: <%s %d>",
698 element_type_name(
699 ces->ces_source_type),
700 ces->ces_source_addr);
701 else
702 printf(" source: <>");
703 }
704 if (intaddr)
705 printf(" intaddr: <%d>", ces->ces_int_addr);
706 if (scsi) {
707 printf(" scsi: <");
708 if (ces->ces_flags & CES_SCSIID_VALID)
709 printf("%d", ces->ces_scsi_id);
710 else
711 putchar('?');
712 putchar(':');
713 if (ces->ces_flags & CES_LUN_VALID)
714 printf("%d", ces->ces_scsi_lun);
715 else
716 putchar('?');
717 putchar('>');
718 }
719 if (ces->ces_designator_length > 0)
720 print_designator(ces->ces_designator,
721 ces->ces_code_set,
722 ces->ces_designator_length);
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 getprogname(), cname);
735 return (1);
736 }
737
738 static int
do_ielem(const char * cname,int argc,char ** argv)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 getprogname(), cname);
758 return (1);
759 }
760
761 static int
do_voltag(const char * cname,int argc,char ** argv)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 = (u_int16_t)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 = (u_int16_t)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 getprogname(), cname);
843 return 1;
844 }
845
846 static u_int16_t
parse_element_type(char * cp)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 ((u_int16_t)elements[i].et_type);
854
855 errx(1, "invalid element type `%s'", cp);
856 /* NOTREACHED */
857 }
858
859 static const char *
element_type_name(int et)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 u_int16_t
parse_element_unit(char * cp)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 ((u_int16_t)i);
882 }
883
884 static int
parse_special(char * cp)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
is_special(char * cp)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 *
bits_to_string(ces_status_flags v,const char * cp)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 (((int)v & (1 << (f - 1))) == 0)
923 continue;
924 (void) snprintf(bp, sizeof(buf) - (size_t)(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
do_return(const char * cname,int argc,char ** argv)941 do_return(const char *cname, int argc, char **argv)
942 {
943 struct changer_element_status *ces;
944 struct changer_move cmd;
945 uint16_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 CHET_VT == type);
971
972 if (NULL == ces)
973 errx(1, "%s: null element status pointer", cname);
974
975 if (!(ces->ces_flags & CES_SOURCE_VALID))
976 errx(1, "%s: no source information", cname);
977
978 (void) memset(&cmd, 0, sizeof(cmd));
979
980 cmd.cm_fromtype = type;
981 cmd.cm_fromunit = element;
982 cmd.cm_totype = ces->ces_source_type;
983 cmd.cm_tounit = ces->ces_source_addr;
984
985 if (ioctl(changer_fd, CHIOMOVE, &cmd) == -1)
986 err(1, "%s: CHIOMOVE", changer_name);
987 free(ces);
988
989 return(0);
990
991 usage:
992 (void) fprintf(stderr, "usage: %s %s "
993 "<from ET> <from EU>\n", getprogname(), cname);
994 return(1);
995 }
996
997 /*
998 * get_element_status()
999 *
1000 * return a *cesr for the specified changer element. This
1001 * routing will malloc()/calloc() the memory. The caller
1002 * should free() it when done.
1003 */
1004 static struct changer_element_status *
get_element_status(unsigned int type,unsigned int element,int use_voltags)1005 get_element_status(unsigned int type, unsigned int element, int use_voltags)
1006 {
1007 struct changer_element_status_request cesr;
1008 struct changer_element_status *ces;
1009
1010 ces = (struct changer_element_status *)
1011 calloc((size_t)1, sizeof(struct changer_element_status));
1012
1013 if (NULL == ces)
1014 errx(1, "can't allocate status storage");
1015
1016 (void)memset(&cesr, 0, sizeof(cesr));
1017
1018 cesr.cesr_element_type = (uint16_t)type;
1019 cesr.cesr_element_base = (uint16_t)element;
1020 cesr.cesr_element_count = 1; /* Only this one element */
1021 if (use_voltags)
1022 cesr.cesr_flags |= CESR_VOLTAGS; /* Grab voltags as well */
1023 cesr.cesr_element_status = ces;
1024
1025 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1026 free(ces);
1027 err(1, "%s: CHIOGSTATUS", changer_name);
1028 /* NOTREACHED */
1029 }
1030
1031 return ces;
1032 }
1033
1034
1035 /*
1036 * find_element()
1037 *
1038 * Given a <voltag> find the chager element and unit, or exit
1039 * with an error if it isn't found. We grab the changer status
1040 * and iterate until we find a match, or crap out.
1041 */
1042 static void
find_element(char * voltag,uint16_t * et,uint16_t * eu)1043 find_element(char *voltag, uint16_t *et, uint16_t *eu)
1044 {
1045 struct changer_params cp;
1046 struct changer_element_status_request cesr;
1047 struct changer_element_status *ch_ces, *ces;
1048 int found = 0;
1049 size_t elem, total_elem;
1050
1051 /*
1052 * Get the changer parameters, we're interested in the counts
1053 * for all types of elements to perform our search.
1054 */
1055 if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
1056 err(1, "%s: CHIOGPARAMS", changer_name);
1057
1058 /* Allocate some memory for the results */
1059 total_elem = (cp.cp_nslots + cp.cp_ndrives
1060 + cp.cp_npickers + cp.cp_nportals);
1061
1062 ch_ces = (struct changer_element_status *)
1063 calloc(total_elem, sizeof(struct changer_element_status));
1064
1065 if (NULL == ch_ces)
1066 errx(1, "can't allocate status storage");
1067
1068 ces = ch_ces;
1069
1070 /* Read in the changer slots */
1071 if (cp.cp_nslots > 0) {
1072 (void) memset(&cesr, 0, sizeof(cesr));
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
cleanup(void)1164 cleanup(void)
1165 {
1166 /* Simple enough... */
1167 (void)close(changer_fd);
1168 }
1169
1170 static void
usage(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 }
1177
1178 #define UTF8CODESET "UTF-8"
1179
1180 static void
print_designator(const char * designator,u_int8_t code_set,u_int8_t designator_length)1181 print_designator(const char *designator, u_int8_t code_set,
1182 u_int8_t designator_length)
1183 {
1184 printf(" serial number: <");
1185 switch (code_set) {
1186 case CES_CODE_SET_ASCII: {
1187 /*
1188 * The driver insures that the string is always NUL terminated.
1189 */
1190 printf("%s", designator);
1191 break;
1192 }
1193 case CES_CODE_SET_UTF_8: {
1194 char *cs_native;
1195
1196 setlocale(LC_ALL, "");
1197 cs_native = nl_langinfo(CODESET);
1198
1199 /* See if we can natively print UTF-8 */
1200 if (strcmp(cs_native, UTF8CODESET) == 0)
1201 cs_native = NULL;
1202
1203 if (cs_native == NULL) {
1204 /* We can natively print UTF-8, so use printf. */
1205 printf("%s", designator);
1206 } else {
1207 int i;
1208
1209 /*
1210 * We can't natively print UTF-8. We should
1211 * convert it to the terminal's codeset, but that
1212 * requires iconv(3) and FreeBSD doesn't have
1213 * iconv(3) in the base system yet. So we use %XX
1214 * notation for non US-ASCII characters instead.
1215 */
1216 for (i = 0; i < designator_length &&
1217 designator[i] != '\0'; i++) {
1218 if ((unsigned char)designator[i] < 0x80)
1219 printf("%c", designator[i]);
1220 else
1221 printf("%%%02x",
1222 (unsigned char)designator[i]);
1223 }
1224 }
1225 break;
1226 }
1227 case CES_CODE_SET_BINARY: {
1228 int i;
1229
1230 for (i = 0; i < designator_length; i++)
1231 printf("%02X%s", designator[i],
1232 (i == designator_length - 1) ? "" : " ");
1233 break;
1234 }
1235 default:
1236 break;
1237 }
1238 printf(">");
1239 }
1240