xref: /titanic_52/usr/src/cmd/hotplug/hotplug.c (revision f79b63829052fcaae660db7f78ce17efd13e15bc)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <locale.h>
30 #include <libintl.h>
31 #include <alloca.h>
32 #include <getopt.h>
33 #include <libhotplug.h>
34 #include <sys/types.h>
35 #include <sys/sunddi.h>
36 #include <sys/ddi_hp.h>
37 
38 #if !defined(TEXT_DOMAIN)		/* should be defined by cc -D */
39 #define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it wasn't */
40 #endif
41 
42 /*
43  * Function prototypes.
44  */
45 static int	cmd_list(int, char **, const char *);
46 static int	cmd_online(int, char **, const char *);
47 static int	cmd_offline(int, char **, const char *);
48 static int	cmd_enable(int, char **, const char *);
49 static int	cmd_disable(int, char **, const char *);
50 static int	cmd_poweron(int, char **, const char *);
51 static int	cmd_poweroff(int, char **, const char *);
52 static int	cmd_getpriv(int, char **, const char *);
53 static int	cmd_setpriv(int, char **, const char *);
54 static int	cmd_changestate(int, char **, const char *);
55 static void	parse_common(int, char **, const char *);
56 static void	parse_flags(int, char **, int *, const char *);
57 static void	parse_target(int, char **, char **, char **, const char *);
58 static void	parse_options(int, char **, char **, const char *);
59 static void	bad_option(int, int, const char *);
60 static void	usage(const char *);
61 static int	list_cb(hp_node_t, void *);
62 static int	list_long_cb(hp_node_t, void *);
63 static int	error_cb(hp_node_t, void *);
64 static void	print_options(const char *);
65 static void	print_error(int);
66 static int	state_atoi(char *);
67 static char	*state_itoa(int);
68 static short	valid_target(int);
69 
70 /*
71  * Define a conversion table for hotplug states.
72  */
73 typedef struct {
74 	int	state;
75 	char	*state_str;
76 	short	valid_target;
77 } hpstate_t;
78 
79 static hpstate_t hpstates[] = {
80 	{ DDI_HP_CN_STATE_EMPTY,	"EMPTY",	0 },
81 	{ DDI_HP_CN_STATE_PRESENT,	"PRESENT",	1 },
82 	{ DDI_HP_CN_STATE_POWERED,	"POWERED",	1 },
83 	{ DDI_HP_CN_STATE_ENABLED,	"ENABLED",	1 },
84 	{ DDI_HP_CN_STATE_PORT_EMPTY,	"PORT-EMPTY",	0 },
85 	{ DDI_HP_CN_STATE_PORT_PRESENT,	"PORT-PRESENT",	1 },
86 	{ DDI_HP_CN_STATE_OFFLINE,	"OFFLINE",	1 },
87 	{ DDI_HP_CN_STATE_ATTACHED,	"ATTACHED",	0 },
88 	{ DDI_HP_CN_STATE_MAINTENANCE,	"MAINTENANCE",	0 },
89 	{ DDI_HP_CN_STATE_ONLINE,	"ONLINE",	1 },
90 	{ 0, 0, 0 }
91 };
92 
93 /*
94  * Define tables of supported subcommands.
95  */
96 typedef struct {
97 	char		*usage_str;
98 	char		*cmd_str;
99 	int		(*func)(int argc, char *argv[], const char *usage_str);
100 } subcmd_t;
101 
102 static subcmd_t	subcmds[] = {
103 	{ "list       [-l] [-v] [<path> [<connection>]]", "list", cmd_list },
104 	{ "online     <path> <port>", "online", cmd_online },
105 	{ "offline    [-f] [-q] <path> <port>", "offline", cmd_offline },
106 	{ "enable     <path> <connector>", "enable", cmd_enable },
107 	{ "disable    [-f] [-q] <path> <connector>", "disable", cmd_disable },
108 	{ "poweron    <path> <connector>", "poweron", cmd_poweron },
109 	{ "poweroff   [-f] [-q] <path> <connector>", "poweroff", cmd_poweroff },
110 	{ "get        -o <options> <path> <connector>", "get", cmd_getpriv },
111 	{ "set        -o <options> <path> <connector>", "set", cmd_setpriv }
112 };
113 
114 static subcmd_t hidden_subcmds[] = {
115 	{ "changestate  [-f] [-q] -s <state> <path> <connection>",
116 	    "changestate", cmd_changestate }
117 };
118 
119 /*
120  * Define tables of command line options.
121  */
122 static const struct option common_opts[] = {
123 	{ "help",	no_argument,		0, '?' },
124 	{ "version",	no_argument,		0, 'V' },
125 	{ 0, 0, 0, 0 }
126 };
127 
128 static const struct option list_opts[] = {
129 	{ "list-path",	no_argument,		0, 'l' },
130 	{ "verbose",	no_argument,		0, 'v' },
131 	{ 0, 0,	0, 0 }
132 };
133 
134 static const struct option flag_opts[] = {
135 	{ "force",	no_argument,		0, 'f' },
136 	{ "query",	no_argument,		0, 'q' },
137 	{ 0, 0,	0, 0 }
138 };
139 
140 static const struct option private_opts[] = {
141 	{ "options",	required_argument,	0, 'o' },
142 	{ 0, 0,	0, 0 }
143 };
144 
145 static const struct option changestate_opts[] = {
146 	{ "force",	no_argument,		0, 'f' },
147 	{ "query",	no_argument,		0, 'q' },
148 	{ "state",	required_argument,	0, 's' },
149 	{ 0, 0,	0, 0 }
150 };
151 
152 /*
153  * Define exit codes.
154  */
155 #define	EXIT_OK		0
156 #define	EXIT_EINVAL	1	/* invalid arguments */
157 #define	EXIT_ENOENT	2	/* path or connection doesn't exist */
158 #define	EXIT_FAILED	3	/* operation failed */
159 #define	EXIT_UNAVAIL	4	/* service not available */
160 
161 /*
162  * Global variables.
163  */
164 static char 	*prog;
165 static char	version[] = "1.0";
166 extern int	errno;
167 
168 /*
169  * main()
170  *
171  *	The main routine determines which subcommand is used,
172  *	and dispatches control to the corresponding function.
173  */
174 int
175 main(int argc, char *argv[])
176 {
177 	int 		i, rv;
178 
179 	(void) setlocale(LC_ALL, "");
180 	(void) textdomain(TEXT_DOMAIN);
181 
182 	if ((prog = strrchr(argv[0], '/')) == NULL)
183 		prog = argv[0];
184 	else
185 		prog++;
186 
187 	if (argc < 2) {
188 		usage(NULL);
189 		return (EXIT_EINVAL);
190 	}
191 
192 	parse_common(argc, argv, NULL);
193 
194 	/* Check the list of defined subcommands. */
195 	for (i = 0; i < (sizeof (subcmds) / sizeof (subcmd_t)); i++) {
196 		if (strcmp(argv[1], subcmds[i].cmd_str) == 0) {
197 			rv = subcmds[i].func(argc - 1, &argv[1],
198 			    subcmds[i].usage_str);
199 			goto finished;
200 		}
201 	}
202 
203 	/* Check the list of hidden subcommands. */
204 	for (i = 0; i < (sizeof (hidden_subcmds) / sizeof (subcmd_t)); i++) {
205 		if (strcmp(argv[1], hidden_subcmds[i].cmd_str) == 0) {
206 			rv = hidden_subcmds[i].func(argc - 1, &argv[1],
207 			    hidden_subcmds[i].usage_str);
208 			goto finished;
209 		}
210 	}
211 
212 	/* No matching subcommand found. */
213 	(void) fprintf(stderr, gettext("ERROR: %s: unknown subcommand '%s'\n"),
214 	    prog, argv[1]);
215 	usage(NULL);
216 	exit(EXIT_EINVAL);
217 
218 finished:
219 	/* Determine exit code */
220 	switch (rv) {
221 	case 0:
222 		break;
223 	case EINVAL:
224 		return (EXIT_EINVAL);
225 	case ENXIO:
226 	case ENOENT:
227 		return (EXIT_ENOENT);
228 	case EBADF:
229 		return (EXIT_UNAVAIL);
230 	default:
231 		return (EXIT_FAILED);
232 	}
233 
234 	return (EXIT_OK);
235 }
236 
237 /*
238  * cmd_list()
239  *
240  *	Subcommand to list hotplug information.
241  */
242 static int
243 cmd_list(int argc, char *argv[], const char *usage_str)
244 {
245 	hp_node_t	root;
246 	char		*path = NULL;
247 	char		*connection = NULL;
248 	boolean_t	long_flag = B_FALSE;
249 	int		flags = 0;
250 	int		opt;
251 
252 	/* Parse command line options */
253 	parse_common(argc, argv, usage_str);
254 	while ((opt = getopt_clip(argc, argv, "lv", list_opts, NULL)) != -1) {
255 		switch (opt) {
256 		case 'l':
257 			long_flag = B_TRUE;
258 			break;
259 		case 'v':
260 			flags |= HPINFOUSAGE;
261 			break;
262 		default:
263 			bad_option(opt, optopt, usage_str);
264 			break;
265 		}
266 	}
267 	parse_target(argc, argv, &path, &connection, usage_str);
268 
269 	/* Default path is "/" */
270 	if (path == NULL)
271 		path = "/";
272 
273 	/* Get hotplug information snapshot */
274 	if ((root = hp_init(path, connection, flags)) == NULL) {
275 		print_error(errno);
276 		return (errno);
277 	}
278 
279 	/* Display hotplug information */
280 	(void) hp_traverse(root, NULL, long_flag ? list_long_cb : list_cb);
281 
282 	/* Discard hotplug information snapshot */
283 	hp_fini(root);
284 
285 	return (0);
286 }
287 
288 /*
289  * cmd_online()
290  *
291  *	Subcommand to online a hotplug port.
292  */
293 static int
294 cmd_online(int argc, char *argv[], const char *usage_str)
295 {
296 	hp_node_t	root;
297 	hp_node_t	results = NULL;
298 	char		*path = NULL;
299 	char		*connection = NULL;
300 	int		rv;
301 
302 	/* Parse command line options */
303 	parse_common(argc, argv, usage_str);
304 	parse_target(argc, argv, &path, &connection, usage_str);
305 
306 	/* Path and connection are required */
307 	if ((path == NULL) || (connection == NULL)) {
308 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
309 		usage(usage_str);
310 		return (EINVAL);
311 	}
312 
313 	/* Get hotplug information snapshot */
314 	if ((root = hp_init(path, connection, 0)) == NULL) {
315 		print_error(errno);
316 		return (errno);
317 	}
318 
319 	/* Verify target is a port */
320 	if (hp_type(root) != HP_NODE_PORT) {
321 		(void) fprintf(stderr,
322 		    gettext("ERROR: invalid target (must be a port).\n"));
323 		hp_fini(root);
324 		return (EINVAL);
325 	}
326 
327 	/* Do state change */
328 	rv = hp_set_state(root, 0, DDI_HP_CN_STATE_ONLINE, &results);
329 
330 	/* Display results */
331 	if (rv == EIO) {
332 		(void) fprintf(stderr, gettext("ERROR: failed to attach device "
333 		    "drivers or other internal errors.\n"));
334 	} else if (rv != 0) {
335 		print_error(rv);
336 	}
337 	if (results != NULL) {
338 		(void) hp_traverse(results, NULL, error_cb);
339 		hp_fini(results);
340 	}
341 
342 	/* Discard hotplug information snapshot */
343 	hp_fini(root);
344 
345 	return (rv);
346 }
347 
348 /*
349  * cmd_offline()
350  *
351  *	Subcommand to offline a hotplug port.
352  */
353 static int
354 cmd_offline(int argc, char *argv[], const char *usage_str)
355 {
356 	hp_node_t	root;
357 	hp_node_t	results = NULL;
358 	char		*path = NULL;
359 	char		*connection = NULL;
360 	int		flags = 0;
361 	int		rv;
362 
363 	/* Parse command line options */
364 	parse_common(argc, argv, usage_str);
365 	parse_flags(argc, argv, &flags, usage_str);
366 	parse_target(argc, argv, &path, &connection, usage_str);
367 
368 	/* Path and connection are required */
369 	if ((path == NULL) || (connection == NULL)) {
370 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
371 		usage(usage_str);
372 		return (EINVAL);
373 	}
374 
375 	/* Get hotplug information snapshot */
376 	if ((root = hp_init(path, connection, 0)) == NULL) {
377 		print_error(errno);
378 		return (errno);
379 	}
380 
381 	/* Verify target is a port */
382 	if (hp_type(root) != HP_NODE_PORT) {
383 		(void) fprintf(stderr,
384 		    gettext("ERROR: invalid target (must be a port).\n"));
385 		hp_fini(root);
386 		return (EINVAL);
387 	}
388 
389 	/* Do state change */
390 	rv = hp_set_state(root, flags, DDI_HP_CN_STATE_OFFLINE, &results);
391 
392 	/* Display results */
393 	print_error(rv);
394 	if (results != NULL) {
395 		(void) hp_traverse(results, NULL, error_cb);
396 		hp_fini(results);
397 	}
398 
399 	/* Discard hotplug information snapshot */
400 	hp_fini(root);
401 
402 	return (rv);
403 }
404 
405 /*
406  * cmd_enable()
407  *
408  *	Subcommand to enable a hotplug connector.
409  */
410 static int
411 cmd_enable(int argc, char *argv[], const char *usage_str)
412 {
413 	hp_node_t	root;
414 	hp_node_t	results = NULL;
415 	char		*path = NULL;
416 	char		*connection = NULL;
417 	int		rv;
418 
419 	/* Parse command line options */
420 	parse_common(argc, argv, usage_str);
421 	parse_target(argc, argv, &path, &connection, usage_str);
422 
423 	/* Path and connection are required */
424 	if ((path == NULL) || (connection == NULL)) {
425 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
426 		usage(usage_str);
427 		return (EINVAL);
428 	}
429 
430 	/* Get hotplug information snapshot */
431 	if ((root = hp_init(path, connection, 0)) == NULL) {
432 		print_error(errno);
433 		return (errno);
434 	}
435 
436 	/* Verify target is a connector */
437 	if (hp_type(root) != HP_NODE_CONNECTOR) {
438 		(void) fprintf(stderr,
439 		    gettext("ERROR: invalid target (must be a connector).\n"));
440 		hp_fini(root);
441 		return (EINVAL);
442 	}
443 
444 	/* Do state change */
445 	rv = hp_set_state(root, 0, DDI_HP_CN_STATE_ENABLED, &results);
446 
447 	/* Display results */
448 	print_error(rv);
449 	if (results != NULL) {
450 		(void) hp_traverse(results, NULL, error_cb);
451 		hp_fini(results);
452 	}
453 
454 	/* Discard hotplug information snapshot */
455 	hp_fini(root);
456 
457 	return (rv);
458 }
459 
460 /*
461  * cmd_disable()
462  *
463  *	Subcommand to disable a hotplug connector.
464  */
465 static int
466 cmd_disable(int argc, char *argv[], const char *usage_str)
467 {
468 	hp_node_t	root;
469 	hp_node_t	results = NULL;
470 	char		*path = NULL;
471 	char		*connection = NULL;
472 	int		flags = 0;
473 	int		rv;
474 
475 	/* Parse command line options */
476 	parse_common(argc, argv, usage_str);
477 	parse_flags(argc, argv, &flags, usage_str);
478 	parse_target(argc, argv, &path, &connection, usage_str);
479 
480 	/* Path and connection are required */
481 	if ((path == NULL) || (connection == NULL)) {
482 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
483 		usage(usage_str);
484 		return (EINVAL);
485 	}
486 
487 	/* Get hotplug information snapshot */
488 	if ((root = hp_init(path, connection, 0)) == NULL) {
489 		print_error(errno);
490 		return (errno);
491 	}
492 
493 	/* Verify target is a connector */
494 	if (hp_type(root) != HP_NODE_CONNECTOR) {
495 		(void) fprintf(stderr,
496 		    gettext("ERROR: invalid target (must be a connector).\n"));
497 		hp_fini(root);
498 		return (EINVAL);
499 	}
500 
501 	/*
502 	 * Do nothing unless the connector is in the ENABLED state.
503 	 * Otherwise this subcommand becomes an alias for 'poweron.'
504 	 */
505 	if (hp_state(root) != DDI_HP_CN_STATE_ENABLED) {
506 		hp_fini(root);
507 		return (0);
508 	}
509 
510 	/* Do state change */
511 	rv = hp_set_state(root, flags, DDI_HP_CN_STATE_POWERED, &results);
512 
513 	/* Display results */
514 	print_error(rv);
515 	if (results != NULL) {
516 		(void) hp_traverse(results, NULL, error_cb);
517 		hp_fini(results);
518 	}
519 
520 	/* Discard hotplug information snapshot */
521 	hp_fini(root);
522 
523 	return (rv);
524 }
525 
526 /*
527  * cmd_poweron()
528  *
529  *	Subcommand to power on a hotplug connector.
530  */
531 static int
532 cmd_poweron(int argc, char *argv[], const char *usage_str)
533 {
534 	hp_node_t	root;
535 	hp_node_t	results = NULL;
536 	char		*path = NULL;
537 	char		*connection = NULL;
538 	int		rv;
539 
540 	/* Parse command line options */
541 	parse_common(argc, argv, usage_str);
542 	parse_target(argc, argv, &path, &connection, usage_str);
543 
544 	/* Path and connection are required */
545 	if ((path == NULL) || (connection == NULL)) {
546 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
547 		usage(usage_str);
548 		return (EINVAL);
549 	}
550 
551 	/* Get hotplug information snapshot */
552 	if ((root = hp_init(path, connection, 0)) == NULL) {
553 		print_error(errno);
554 		return (errno);
555 	}
556 
557 	/* Verify target is a connector */
558 	if (hp_type(root) != HP_NODE_CONNECTOR) {
559 		(void) fprintf(stderr,
560 		    gettext("ERROR: invalid target (must be a connector).\n"));
561 		hp_fini(root);
562 		return (EINVAL);
563 	}
564 
565 	/*
566 	 * Do nothing if the connector is already powered.
567 	 * Otherwise this subcommand becomes an alias for 'disable.'
568 	 */
569 	if (hp_state(root) >= DDI_HP_CN_STATE_POWERED) {
570 		hp_fini(root);
571 		return (0);
572 	}
573 
574 	/* Do state change */
575 	rv = hp_set_state(root, 0, DDI_HP_CN_STATE_POWERED, &results);
576 
577 	/* Display results */
578 	print_error(rv);
579 	if (results != NULL) {
580 		(void) hp_traverse(results, NULL, error_cb);
581 		hp_fini(results);
582 	}
583 
584 	/* Discard hotplug information snapshot */
585 	hp_fini(root);
586 
587 	return (rv);
588 }
589 
590 /*
591  * cmd_poweroff()
592  *
593  *	Subcommand to power off a hotplug connector.
594  */
595 static int
596 cmd_poweroff(int argc, char *argv[], const char *usage_str)
597 {
598 	hp_node_t	root;
599 	hp_node_t	results = NULL;
600 	char		*path = NULL;
601 	char		*connection = NULL;
602 	int		flags = 0;
603 	int		rv;
604 
605 	/* Parse command line options */
606 	parse_common(argc, argv, usage_str);
607 	parse_flags(argc, argv, &flags, usage_str);
608 	parse_target(argc, argv, &path, &connection, usage_str);
609 
610 	/* Path and connection are required */
611 	if ((path == NULL) || (connection == NULL)) {
612 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
613 		usage(usage_str);
614 		return (EINVAL);
615 	}
616 
617 	/* Get hotplug information snapshot */
618 	if ((root = hp_init(path, connection, 0)) == NULL) {
619 		print_error(errno);
620 		return (errno);
621 	}
622 
623 	/* Verify target is a connector */
624 	if (hp_type(root) != HP_NODE_CONNECTOR) {
625 		(void) fprintf(stderr,
626 		    gettext("ERROR: invalid target (must be a connector).\n"));
627 		hp_fini(root);
628 		return (EINVAL);
629 	}
630 
631 	/* Do state change */
632 	rv = hp_set_state(root, flags, DDI_HP_CN_STATE_PRESENT, &results);
633 
634 	/* Display results */
635 	print_error(rv);
636 	if (results != NULL) {
637 		(void) hp_traverse(results, NULL, error_cb);
638 		hp_fini(results);
639 	}
640 
641 	/* Discard hotplug information snapshot */
642 	hp_fini(root);
643 
644 	return (rv);
645 }
646 
647 /*
648  * cmd_getpriv()
649  *
650  *	Subcommand to get and display bus private options.
651  */
652 static int
653 cmd_getpriv(int argc, char *argv[], const char *usage_str)
654 {
655 	hp_node_t	root;
656 	char		*path = NULL;
657 	char		*connection = NULL;
658 	char		*options = NULL;
659 	char		*results = NULL;
660 	int		rv;
661 
662 	/* Parse command line options */
663 	parse_common(argc, argv, usage_str);
664 	parse_options(argc, argv, &options, usage_str);
665 	parse_target(argc, argv, &path, &connection, usage_str);
666 
667 	/* Options, path, and connection are all required */
668 	if ((options == NULL) || (path == NULL) || (connection == NULL)) {
669 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
670 		usage(usage_str);
671 		return (EINVAL);
672 	}
673 
674 	/* Get hotplug information snapshot */
675 	if ((root = hp_init(path, connection, 0)) == NULL) {
676 		print_error(errno);
677 		return (errno);
678 	}
679 
680 	/* Verify target is a connector */
681 	if (hp_type(root) != HP_NODE_CONNECTOR) {
682 		(void) fprintf(stderr,
683 		    gettext("ERROR: invalid target (must be a connector).\n"));
684 		hp_fini(root);
685 		return (EINVAL);
686 	}
687 
688 	/* Do the operation */
689 	rv = hp_get_private(root, options, &results);
690 
691 	/* Display results */
692 	if (rv == ENOTSUP) {
693 		(void) fprintf(stderr,
694 		    gettext("ERROR: unsupported property name or value.\n"));
695 		(void) fprintf(stderr,
696 		    gettext("(Properties may depend upon connector state.)\n"));
697 	} else if (rv != 0) {
698 		print_error(rv);
699 	}
700 	if (results != NULL) {
701 		print_options(results);
702 		free(results);
703 	}
704 
705 	/* Discard hotplug information snapshot */
706 	hp_fini(root);
707 
708 	return (rv);
709 }
710 
711 /*
712  * cmd_setpriv()
713  *
714  *	Subcommand to set bus private options.
715  */
716 static int
717 cmd_setpriv(int argc, char *argv[], const char *usage_str)
718 {
719 	hp_node_t	root;
720 	char		*path = NULL;
721 	char		*connection = NULL;
722 	char		*options = NULL;
723 	char		*results = NULL;
724 	int		rv;
725 
726 	/* Parse command line options */
727 	parse_common(argc, argv, usage_str);
728 	parse_options(argc, argv, &options, usage_str);
729 	parse_target(argc, argv, &path, &connection, usage_str);
730 
731 	/* Options, path, and connection are all required */
732 	if ((options == NULL) || (path == NULL) || (connection == NULL)) {
733 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
734 		usage(usage_str);
735 		return (EINVAL);
736 	}
737 
738 	/* Get hotplug information snapshot */
739 	if ((root = hp_init(path, connection, 0)) == NULL) {
740 		print_error(errno);
741 		return (errno);
742 	}
743 
744 	/* Verify target is a connector */
745 	if (hp_type(root) != HP_NODE_CONNECTOR) {
746 		(void) fprintf(stderr,
747 		    gettext("ERROR: invalid target (must be a connector).\n"));
748 		hp_fini(root);
749 		return (EINVAL);
750 	}
751 
752 	/* Do the operation */
753 	rv = hp_set_private(root, options, &results);
754 
755 	/* Display results */
756 	if (rv == ENOTSUP) {
757 		(void) fprintf(stderr,
758 		    gettext("ERROR: unsupported property name or value.\n"));
759 		(void) fprintf(stderr,
760 		    gettext("(Properties may depend upon connector state.)\n"));
761 	} else if (rv != 0) {
762 		print_error(rv);
763 	}
764 	if (results != NULL) {
765 		print_options(results);
766 		free(results);
767 	}
768 
769 	/* Discard hotplug information snapshot */
770 	hp_fini(root);
771 
772 	return (rv);
773 }
774 
775 /*
776  * cmd_changestate()
777  *
778  *	Subcommand to initiate a state change operation.  This is
779  *	a hidden subcommand to directly set a connector or port to
780  *	a specific target state.
781  */
782 static int
783 cmd_changestate(int argc, char *argv[], const char *usage_str)
784 {
785 	hp_node_t	root;
786 	hp_node_t	results = NULL;
787 	char		*path = NULL;
788 	char		*connection = NULL;
789 	int		state = -1;
790 	int		flags = 0;
791 	int		opt, rv;
792 
793 	/* Parse command line options */
794 	parse_common(argc, argv, usage_str);
795 	while ((opt = getopt_clip(argc, argv, "fqs:", changestate_opts,
796 	    NULL)) != -1) {
797 		switch (opt) {
798 		case 'f':
799 			flags |= HPFORCE;
800 			break;
801 		case 'q':
802 			flags |= HPQUERY;
803 			break;
804 		case 's':
805 			if ((state = state_atoi(optarg)) == -1) {
806 				(void) printf("ERROR: invalid target state\n");
807 				return (EINVAL);
808 			}
809 			break;
810 		default:
811 			bad_option(opt, optopt, usage_str);
812 			break;
813 		}
814 	}
815 	parse_target(argc, argv, &path, &connection, usage_str);
816 
817 	/* State, path, and connection are all required */
818 	if ((state == -1) || (path == NULL) || (connection == NULL)) {
819 		(void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
820 		usage(usage_str);
821 		return (EINVAL);
822 	}
823 
824 	/* Check that target state is valid */
825 	if (valid_target(state) == 0) {
826 		(void) fprintf(stderr,
827 		    gettext("ERROR: invalid target state\n"));
828 		return (EINVAL);
829 	}
830 
831 	/* Get hotplug information snapshot */
832 	if ((root = hp_init(path, connection, 0)) == NULL) {
833 		print_error(errno);
834 		return (errno);
835 	}
836 
837 	/* Initiate state change operation on root of snapshot */
838 	rv = hp_set_state(root, flags, state, &results);
839 
840 	/* Display results */
841 	print_error(rv);
842 	if (results) {
843 		(void) hp_traverse(results, NULL, error_cb);
844 		hp_fini(results);
845 	}
846 
847 	/* Discard hotplug information snapshot */
848 	hp_fini(root);
849 
850 	return (rv);
851 }
852 
853 /*
854  * parse_common()
855  *
856  *	Parse command line options that are common to the
857  *	entire program, and to each of its subcommands.
858  */
859 static void
860 parse_common(int argc, char *argv[], const char *usage_str)
861 {
862 	int		opt;
863 	extern int	opterr;
864 	extern int	optind;
865 
866 	/* Turn off error reporting */
867 	opterr = 0;
868 
869 	while ((opt = getopt_clip(argc, argv, "?V", common_opts, NULL)) != -1) {
870 		switch (opt) {
871 		case '?':
872 			if (optopt == '?') {
873 				usage(usage_str);
874 				exit(0);
875 			}
876 			break;
877 		case 'V':
878 			(void) printf(gettext("%s: Version %s\n"),
879 			    prog, version);
880 			exit(0);
881 		default:
882 			break;
883 		}
884 	}
885 
886 	/* Reset option index */
887 	optind = 1;
888 }
889 
890 /*
891  * parse_flags()
892  *
893  *	Parse command line flags common to all downward state
894  *	change operations (offline, disable, poweoff).
895  */
896 static void
897 parse_flags(int argc, char *argv[], int *flagsp, const char *usage_str)
898 {
899 	int	opt;
900 	int	flags = 0;
901 
902 	while ((opt = getopt_clip(argc, argv, "fq", flag_opts, NULL)) != -1) {
903 		switch (opt) {
904 		case 'f':
905 			flags |= HPFORCE;
906 			break;
907 		case 'q':
908 			flags |= HPQUERY;
909 			break;
910 		default:
911 			bad_option(opt, optopt, usage_str);
912 			break;
913 		}
914 	}
915 
916 	*flagsp = flags;
917 }
918 
919 /*
920  * parse_options()
921  *
922  *	Parse command line options common to the bus private set and
923  *	get subcommands.
924  */
925 static void
926 parse_options(int argc, char *argv[], char **optionsp, const char *usage_str)
927 {
928 	int	opt;
929 
930 	while ((opt = getopt_clip(argc, argv, "o:", private_opts,
931 	    NULL)) != -1) {
932 		switch (opt) {
933 		case 'o':
934 			*optionsp = optarg;
935 			break;
936 		default:
937 			bad_option(opt, optopt, usage_str);
938 			break;
939 		}
940 	}
941 }
942 
943 /*
944  * parse_target()
945  *
946  *	Parse the target path and connection name from the command line.
947  */
948 static void
949 parse_target(int argc, char *argv[], char **pathp, char **connectionp,
950     const char *usage_str)
951 {
952 	extern int	optind;
953 
954 	if (optind < argc)
955 		*pathp = argv[optind++];
956 
957 	if (optind < argc)
958 		*connectionp = argv[optind++];
959 
960 	if (optind < argc) {
961 		(void) fprintf(stderr, gettext("ERROR: too many arguments.\n"));
962 		usage(usage_str);
963 		exit(EINVAL);
964 	}
965 }
966 
967 /*
968  * bad_option()
969  *
970  *	Routine to handle bad command line options.
971  */
972 static void
973 bad_option(int opt, int optopt, const char *usage_str)
974 {
975 	switch (opt) {
976 	case ':':
977 		(void) fprintf(stderr,
978 		    gettext("ERROR: option '%c' requires an argument.\n"),
979 		    optopt);
980 		break;
981 	default:
982 		if (optopt == '?') {
983 			usage(usage_str);
984 			exit(EXIT_OK);
985 		}
986 		(void) fprintf(stderr,
987 		    gettext("ERROR: unrecognized option '%c'.\n"), optopt);
988 		break;
989 	}
990 
991 	usage(usage_str);
992 
993 	exit(EXIT_EINVAL);
994 }
995 
996 /*
997  * usage()
998  *
999  *	Display general usage of the command.  Including
1000  *	the usage synopsis of each defined subcommand.
1001  */
1002 static void
1003 usage(const char *usage_str)
1004 {
1005 	int	i;
1006 
1007 	if (usage_str != NULL) {
1008 		(void) fprintf(stderr, gettext("Usage:   %s  %s\n\n"),
1009 		    prog, usage_str);
1010 		return;
1011 	}
1012 
1013 	(void) fprintf(stderr, gettext("Usage:  %s  <subcommand> [<args>]\n\n"),
1014 	    prog);
1015 
1016 	(void) fprintf(stderr, gettext("Subcommands:\n\n"));
1017 
1018 	for (i = 0; i < (sizeof (subcmds) / sizeof (subcmd_t)); i++)
1019 		(void) fprintf(stderr, "   %s\n\n", subcmds[i].usage_str);
1020 }
1021 
1022 /*
1023  * list_cb()
1024  *
1025  *	Callback function for hp_traverse(), to display nodes
1026  *	of a hotplug information snapshot.  (Short version.)
1027  */
1028 /*ARGSUSED*/
1029 static int
1030 list_cb(hp_node_t node, void *arg)
1031 {
1032 	hp_node_t	parent;
1033 
1034 	/* Indent */
1035 	for (parent = hp_parent(node); parent; parent = hp_parent(parent))
1036 		if (hp_type(parent) == HP_NODE_DEVICE)
1037 			(void) printf("     ");
1038 
1039 	switch (hp_type(node)) {
1040 	case HP_NODE_DEVICE:
1041 		(void) printf("%s\n", hp_name(node));
1042 		break;
1043 
1044 	case HP_NODE_CONNECTOR:
1045 		(void) printf("[%s]", hp_name(node));
1046 		(void) printf("  (%s)", state_itoa(hp_state(node)));
1047 		(void) printf("\n");
1048 		break;
1049 
1050 	case HP_NODE_PORT:
1051 		(void) printf("<%s>", hp_name(node));
1052 		(void) printf("  (%s)", state_itoa(hp_state(node)));
1053 		(void) printf("\n");
1054 		break;
1055 
1056 	case HP_NODE_USAGE:
1057 		(void) printf("{ %s }\n", hp_usage(node));
1058 		break;
1059 	}
1060 
1061 	return (HP_WALK_CONTINUE);
1062 }
1063 
1064 /*
1065  * list_long_cb()
1066  *
1067  *	Callback function for hp_traverse(), to display nodes
1068  *	of a hotplug information snapshot.  (Long version.)
1069  */
1070 /*ARGSUSED*/
1071 static int
1072 list_long_cb(hp_node_t node, void *arg)
1073 {
1074 	char	path[MAXPATHLEN];
1075 	char	connection[MAXPATHLEN];
1076 
1077 	if (hp_type(node) != HP_NODE_USAGE) {
1078 		if (hp_path(node, path, connection) != 0)
1079 			return (HP_WALK_CONTINUE);
1080 		(void) printf("%s", path);
1081 	}
1082 
1083 	switch (hp_type(node)) {
1084 	case HP_NODE_CONNECTOR:
1085 		(void) printf(" [%s]", connection);
1086 		(void) printf(" (%s)", state_itoa(hp_state(node)));
1087 		break;
1088 
1089 	case HP_NODE_PORT:
1090 		(void) printf(" <%s>", connection);
1091 		(void) printf(" (%s)", state_itoa(hp_state(node)));
1092 		break;
1093 
1094 	case HP_NODE_USAGE:
1095 		(void) printf("    { %s }", hp_usage(node));
1096 		break;
1097 	}
1098 
1099 	(void) printf("\n");
1100 
1101 	return (HP_WALK_CONTINUE);
1102 }
1103 
1104 /*
1105  * error_cb()
1106  *
1107  *	Callback function for hp_traverse(), to display
1108  *	error results from a state change operation.
1109  */
1110 /*ARGSUSED*/
1111 static int
1112 error_cb(hp_node_t node, void *arg)
1113 {
1114 	hp_node_t	child;
1115 	char		*usage_str;
1116 	static char	path[MAXPATHLEN];
1117 	static char	connection[MAXPATHLEN];
1118 
1119 	if (((child = hp_child(node)) != NULL) &&
1120 	    (hp_type(child) == HP_NODE_USAGE)) {
1121 		if (hp_path(node, path, connection) == 0)
1122 			(void) printf("%s:\n", path);
1123 		return (HP_WALK_CONTINUE);
1124 	}
1125 
1126 	if ((hp_type(node) == HP_NODE_USAGE) &&
1127 	    ((usage_str = hp_usage(node)) != NULL))
1128 		(void) printf("   { %s }\n", usage_str);
1129 
1130 	return (HP_WALK_CONTINUE);
1131 }
1132 
1133 /*
1134  * print_options()
1135  *
1136  *	Parse and display bus private options.  The options are
1137  *	formatted as a string which conforms to the getsubopt(3C)
1138  *	format.  This routine only splits the string elements as
1139  *	separated by commas, and displays each portion on its own
1140  *	separate line of output.
1141  */
1142 static void
1143 print_options(const char *options)
1144 {
1145 	char	*buf, *curr, *next;
1146 	size_t	len;
1147 
1148 	/* Do nothing if options string is empty */
1149 	if ((len = strlen(options)) == 0)
1150 		return;
1151 
1152 	/* To avoid modifying the input string, make a copy on the stack */
1153 	if ((buf = (char *)alloca(len + 1)) == NULL) {
1154 		(void) printf("%s\n", options);
1155 		return;
1156 	}
1157 	(void) strlcpy(buf, options, len + 1);
1158 
1159 	/* Iterate through each comma-separated name/value pair */
1160 	curr = buf;
1161 	do {
1162 		if ((next = strchr(curr, ',')) != NULL) {
1163 			*next = '\0';
1164 			next++;
1165 		}
1166 		(void) printf("%s\n", curr);
1167 	} while ((curr = next) != NULL);
1168 }
1169 
1170 /*
1171  * print_error()
1172  *
1173  *	Common routine to print error numbers in an appropriate way.
1174  *	Prints nothing if error code is 0.
1175  */
1176 static void
1177 print_error(int error)
1178 {
1179 	switch (error) {
1180 	case 0:
1181 		/* No error */
1182 		return;
1183 	case EACCES:
1184 		(void) fprintf(stderr,
1185 		    gettext("ERROR: operation not authorized.\n"));
1186 		break;
1187 	case EBADF:
1188 		(void) fprintf(stderr,
1189 		    gettext("ERROR: hotplug service is not available.\n"));
1190 		break;
1191 	case EBUSY:
1192 		(void) fprintf(stderr,
1193 		    gettext("ERROR: devices or resources are busy.\n"));
1194 		break;
1195 	case EEXIST:
1196 		(void) fprintf(stderr,
1197 		    gettext("ERROR: resource already exists.\n"));
1198 		break;
1199 	case EFAULT:
1200 		(void) fprintf(stderr,
1201 		    gettext("ERROR: internal failure in hotplug service.\n"));
1202 		break;
1203 	case EINVAL:
1204 		(void) fprintf(stderr,
1205 		    gettext("ERROR: invalid arguments.\n"));
1206 		break;
1207 	case ENOENT:
1208 		(void) fprintf(stderr,
1209 		    gettext("ERROR: there are no connections to display.\n"));
1210 		(void) fprintf(stderr,
1211 		    gettext("(See hotplug(1m) for more information.)\n"));
1212 		break;
1213 	case ENXIO:
1214 		(void) fprintf(stderr,
1215 		    gettext("ERROR: no such path or connection.\n"));
1216 		break;
1217 	case ENOMEM:
1218 		(void) fprintf(stderr,
1219 		    gettext("ERROR: not enough memory.\n"));
1220 		break;
1221 	case ENOTSUP:
1222 		(void) fprintf(stderr,
1223 		    gettext("ERROR: operation not supported.\n"));
1224 		break;
1225 	case EIO:
1226 		(void) fprintf(stderr,
1227 		    gettext("ERROR: hardware or driver specific failure.\n"));
1228 		break;
1229 	default:
1230 		(void) fprintf(stderr, gettext("ERROR: operation failed: %s\n"),
1231 		    strerror(error));
1232 		break;
1233 	}
1234 }
1235 
1236 /*
1237  * state_atoi()
1238  *
1239  *	Convert a hotplug state from a string to an integer.
1240  */
1241 static int
1242 state_atoi(char *state)
1243 {
1244 	int	i;
1245 
1246 	for (i = 0; hpstates[i].state_str != NULL; i++)
1247 		if (strcasecmp(state, hpstates[i].state_str) == 0)
1248 			return (hpstates[i].state);
1249 
1250 	return (-1);
1251 }
1252 
1253 /*
1254  * state_itoa()
1255  *
1256  *	Convert a hotplug state from an integer to a string.
1257  */
1258 static char *
1259 state_itoa(int state)
1260 {
1261 	static char	unknown[] = "UNKNOWN";
1262 	int		i;
1263 
1264 	for (i = 0; hpstates[i].state_str != NULL; i++)
1265 		if (state == hpstates[i].state)
1266 			return (hpstates[i].state_str);
1267 
1268 	return (unknown);
1269 }
1270 
1271 /*
1272  * valid_target()
1273  *
1274  *	Check if a state is a valid target for a changestate command.
1275  */
1276 static short
1277 valid_target(int state)
1278 {
1279 	int	i;
1280 
1281 	for (i = 0; hpstates[i].state_str != NULL; i++)
1282 		if (state == hpstates[i].state)
1283 			return (hpstates[i].valid_target);
1284 
1285 	return (0);
1286 }
1287