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