xref: /titanic_50/usr/src/lib/libhotplug/common/libhotplug.c (revision 269473047d747f7815af570197e4ef7322d3632c)
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 <stdarg.h>
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include <errno.h>
32 #include <string.h>
33 #include <door.h>
34 #include <libnvpair.h>
35 #include <libhotplug.h>
36 #include <libhotplug_impl.h>
37 #include <sys/sunddi.h>
38 #include <sys/ddi_hp.h>
39 
40 static void	i_hp_dprintf(const char *fmt, ...);
41 static int	i_hp_pack_branch(hp_node_t, char **, size_t *);
42 static int	i_hp_pack_node(hp_node_t, char **, size_t *);
43 static int	i_hp_unpack_node(char *, size_t, hp_node_t, hp_node_t *);
44 static int	i_hp_unpack_branch(char *, size_t, hp_node_t, hp_node_t *);
45 static int	i_hp_call_hotplugd(nvlist_t *, nvlist_t **);
46 static nvlist_t	*i_hp_set_args(hp_cmd_t, const char *, const char *, uint_t,
47 		    const char *, int);
48 static int	i_hp_parse_results(nvlist_t *, hp_node_t *, char **);
49 
50 /*
51  * Global flag to enable debug features.
52  */
53 int	libhotplug_debug = 0;
54 
55 /*
56  * hp_init()
57  *
58  *	Initialize a hotplug information snapshot.
59  */
60 hp_node_t
hp_init(const char * path,const char * connection,uint_t flags)61 hp_init(const char *path, const char *connection, uint_t flags)
62 {
63 	nvlist_t	*args;
64 	nvlist_t	*results;
65 	hp_node_t	root = NULL;
66 	int		rv;
67 
68 	i_hp_dprintf("hp_init: path=%p, connection=%p, flags=0x%x\n",
69 	    (void *)path, (void *)connection, flags);
70 
71 	/* Check arguments */
72 	if ((path == NULL) || !HP_INIT_FLAGS_VALID(flags)) {
73 		i_hp_dprintf("hp_init: invalid arguments.\n");
74 		errno = EINVAL;
75 		return (NULL);
76 	}
77 
78 	/* Build arguments for door call */
79 	if ((args = i_hp_set_args(HP_CMD_GETINFO, path, connection, flags,
80 	    NULL, 0)) == NULL) {
81 		i_hp_dprintf("hp_init: cannot build arguments nvlist.\n");
82 		errno = ENOMEM;
83 		return (NULL);
84 	}
85 
86 	/* Make the door call to hotplugd */
87 	rv = i_hp_call_hotplugd(args, &results);
88 
89 	/* Arguments no longer needed */
90 	nvlist_free(args);
91 
92 	/* Parse additional results, if any */
93 	if ((rv == 0) && (results != NULL)) {
94 		rv = i_hp_parse_results(results, &root, NULL);
95 		nvlist_free(results);
96 	}
97 
98 	/* Check for errors */
99 	if (rv != 0) {
100 		i_hp_dprintf("hp_init: failure (%s).\n", strerror(rv));
101 		if (root)
102 			hp_fini(root);
103 		errno = rv;
104 		return (NULL);
105 	}
106 
107 	/* Success requires an info snapshot */
108 	if (root == NULL) {
109 		i_hp_dprintf("hp_init: missing info snapshot.\n");
110 		errno = EFAULT;
111 		return (NULL);
112 	}
113 
114 	/* Success */
115 	return (root);
116 }
117 
118 /*
119  * hp_fini()
120  *
121  *	Terminate and clean-up a hotplug information snapshot.
122  */
123 void
hp_fini(hp_node_t root)124 hp_fini(hp_node_t root)
125 {
126 	hp_node_t	node;
127 	hp_node_t	sibling;
128 	char		*basepath;
129 
130 	i_hp_dprintf("hp_fini: root=%p\n", (void *)root);
131 
132 	if (root == NULL) {
133 		i_hp_dprintf("hp_fini: invalid arguments.\n");
134 		return;
135 	}
136 
137 	/* Extract and free base path */
138 	if (root->hp_basepath) {
139 		basepath = root->hp_basepath;
140 		for (node = root; node != NULL; node = node->hp_sibling)
141 			node->hp_basepath = NULL;
142 		free(basepath);
143 	}
144 
145 	/* Destroy the nodes */
146 	node = root;
147 	while (node) {
148 		sibling = node->hp_sibling;
149 		if (node->hp_child)
150 			hp_fini(node->hp_child);
151 		if (node->hp_name)
152 			free(node->hp_name);
153 		if (node->hp_usage)
154 			free(node->hp_usage);
155 		if (node->hp_description)
156 			free(node->hp_description);
157 		free(node);
158 		node = sibling;
159 	}
160 }
161 
162 /*
163  * hp_traverse()
164  *
165  *	Walk a graph of hotplug nodes, executing a callback on each node.
166  */
167 int
hp_traverse(hp_node_t root,void * arg,int (* hp_callback)(hp_node_t,void * arg))168 hp_traverse(hp_node_t root, void *arg, int (*hp_callback)(hp_node_t, void *arg))
169 {
170 	int		rv;
171 	hp_node_t	node;
172 
173 	i_hp_dprintf("hp_traverse: root=%p, arg=%p, hp_callback=%p\n",
174 	    (void *)root, arg, (void *)hp_callback);
175 
176 	/* Check arguments */
177 	if ((root == NULL) || (hp_callback == NULL)) {
178 		i_hp_dprintf("hp_traverse: invalid arguments.\n");
179 		errno = EINVAL;
180 		return (-1);
181 	}
182 
183 	for (node = root; node; node = node->hp_sibling) {
184 		rv = hp_callback(node, arg);
185 
186 		if (rv == HP_WALK_TERMINATE) {
187 			i_hp_dprintf("hp_traverse: walk terminated.\n");
188 			return (HP_WALK_TERMINATE);
189 		}
190 
191 		if (node->hp_child && (rv != HP_WALK_PRUNECHILD))
192 			if (hp_traverse(node->hp_child, arg, hp_callback) ==
193 			    HP_WALK_TERMINATE) {
194 				i_hp_dprintf("hp_traverse: walk terminated.\n");
195 				return (HP_WALK_TERMINATE);
196 			}
197 
198 		if (rv == HP_WALK_PRUNESIBLING)
199 			break;
200 	}
201 
202 	return (0);
203 }
204 
205 /*
206  * hp_type()
207  *
208  *	Return a node's type.
209  */
210 int
hp_type(hp_node_t node)211 hp_type(hp_node_t node)
212 {
213 	i_hp_dprintf("hp_type: node=%p\n", (void *)node);
214 
215 	if (node == NULL) {
216 		i_hp_dprintf("hp_type: invalid arguments.\n");
217 		errno = EINVAL;
218 		return (-1);
219 	}
220 
221 	return (node->hp_type);
222 }
223 
224 /*
225  * hp_name()
226  *
227  *	Return a node's name.
228  */
229 char *
hp_name(hp_node_t node)230 hp_name(hp_node_t node)
231 {
232 	i_hp_dprintf("hp_name: node=%p\n", (void *)node);
233 
234 	if (node == NULL) {
235 		i_hp_dprintf("hp_name: invalid arguments.\n");
236 		errno = EINVAL;
237 		return (NULL);
238 	}
239 
240 	if (node->hp_name == NULL) {
241 		i_hp_dprintf("hp_name: missing name value.\n");
242 		errno = EFAULT;
243 	}
244 
245 	return (node->hp_name);
246 }
247 
248 /*
249  * hp_state()
250  *
251  *	Return a node's current state.
252  */
253 int
hp_state(hp_node_t node)254 hp_state(hp_node_t node)
255 {
256 	i_hp_dprintf("hp_state: node=%p\n", (void *)node);
257 
258 	if (node == NULL) {
259 		i_hp_dprintf("hp_state: invalid arguments.\n");
260 		errno = EINVAL;
261 		return (-1);
262 	}
263 
264 	if ((node->hp_type != HP_NODE_CONNECTOR) &&
265 	    (node->hp_type != HP_NODE_PORT)) {
266 		i_hp_dprintf("hp_state: operation not supported.\n");
267 		errno = ENOTSUP;
268 		return (-1);
269 	}
270 
271 	return (node->hp_state);
272 }
273 
274 /*
275  * hp_usage()
276  *
277  *	Return a usage description for usage nodes.
278  */
279 char *
hp_usage(hp_node_t node)280 hp_usage(hp_node_t node)
281 {
282 	i_hp_dprintf("hp_usage: node=%p\n", (void *)node);
283 
284 	if (node == NULL) {
285 		i_hp_dprintf("hp_usage: invalid arguments.\n");
286 		errno = EINVAL;
287 		return (NULL);
288 	}
289 
290 	if (node->hp_type != HP_NODE_USAGE) {
291 		i_hp_dprintf("hp_usage: operation not supported.\n");
292 		errno = ENOTSUP;
293 		return (NULL);
294 	}
295 
296 	if (node->hp_usage == NULL) {
297 		i_hp_dprintf("hp_usage: missing usage value.\n");
298 		errno = EFAULT;
299 	}
300 
301 	return (node->hp_usage);
302 }
303 
304 /*
305  * hp_description()
306  *
307  *	Return a type description (e.g. "PCI slot") for connection nodes.
308  */
309 char *
hp_description(hp_node_t node)310 hp_description(hp_node_t node)
311 {
312 	i_hp_dprintf("hp_description: node=%p\n", (void *)node);
313 
314 	if (node == NULL) {
315 		i_hp_dprintf("hp_description: invalid arguments.\n");
316 		errno = EINVAL;
317 		return (NULL);
318 	}
319 
320 	if ((node->hp_type != HP_NODE_CONNECTOR) &&
321 	    (node->hp_type != HP_NODE_PORT)) {
322 		i_hp_dprintf("hp_description: operation not supported.\n");
323 		errno = ENOTSUP;
324 		return (NULL);
325 	}
326 
327 	if (node->hp_description == NULL) {
328 		i_hp_dprintf("hp_description: missing description value.\n");
329 		errno = EFAULT;
330 	}
331 
332 	return (node->hp_description);
333 }
334 
335 /*
336  * hp_last_change()
337  *
338  *	Return when the state of a connection was last changed.
339  */
340 time_t
hp_last_change(hp_node_t node)341 hp_last_change(hp_node_t node)
342 {
343 	i_hp_dprintf("hp_last_change: node=%p\n", (void *)node);
344 
345 	if (node == NULL) {
346 		i_hp_dprintf("hp_last_change: invalid arguments.\n");
347 		errno = EINVAL;
348 		return (NULL);
349 	}
350 
351 	if ((node->hp_type != HP_NODE_CONNECTOR) &&
352 	    (node->hp_type != HP_NODE_PORT)) {
353 		i_hp_dprintf("hp_last_change: operation not supported.\n");
354 		errno = ENOTSUP;
355 		return (NULL);
356 	}
357 
358 	return (node->hp_last_change);
359 }
360 
361 /*
362  * hp_parent()
363  *
364  *	Return a node's parent node.
365  */
366 hp_node_t
hp_parent(hp_node_t node)367 hp_parent(hp_node_t node)
368 {
369 	i_hp_dprintf("hp_parent: node=%p\n", (void *)node);
370 
371 	if (node == NULL) {
372 		i_hp_dprintf("hp_parent: invalid arguments.\n");
373 		errno = EINVAL;
374 		return (NULL);
375 	}
376 
377 	if (node->hp_parent == NULL) {
378 		i_hp_dprintf("hp_parent: node has no parent.\n");
379 		errno = ENXIO;
380 	}
381 
382 	return (node->hp_parent);
383 }
384 
385 /*
386  * hp_child()
387  *
388  *	Return a node's first child node.
389  */
390 hp_node_t
hp_child(hp_node_t node)391 hp_child(hp_node_t node)
392 {
393 	i_hp_dprintf("hp_child: node=%p\n", (void *)node);
394 
395 	if (node == NULL) {
396 		i_hp_dprintf("hp_child: invalid arguments.\n");
397 		errno = EINVAL;
398 		return (NULL);
399 	}
400 
401 	if (node->hp_child == NULL) {
402 		i_hp_dprintf("hp_child: node has no child.\n");
403 		errno = ENXIO;
404 	}
405 
406 	return (node->hp_child);
407 }
408 
409 /*
410  * hp_sibling()
411  *
412  *	Return a node's next sibling node.
413  */
414 hp_node_t
hp_sibling(hp_node_t node)415 hp_sibling(hp_node_t node)
416 {
417 	i_hp_dprintf("hp_sibling: node=%p\n", (void *)node);
418 
419 	if (node == NULL) {
420 		i_hp_dprintf("hp_sibling: invalid arguments.\n");
421 		errno = EINVAL;
422 		return (NULL);
423 	}
424 
425 	if (node->hp_sibling == NULL) {
426 		i_hp_dprintf("hp_sibling: node has no sibling.\n");
427 		errno = ENXIO;
428 	}
429 
430 	return (node->hp_sibling);
431 }
432 
433 /*
434  * hp_path()
435  *
436  *	Return the path (and maybe connection name) of a node.
437  *	The caller must supply two buffers, each MAXPATHLEN size.
438  */
439 int
hp_path(hp_node_t node,char * path,char * connection)440 hp_path(hp_node_t node, char *path, char *connection)
441 {
442 	hp_node_t	root;
443 	hp_node_t	parent;
444 	int		i;
445 	char		*s;
446 	char		components[MAXPATHLEN];
447 
448 	i_hp_dprintf("hp_path: node=%p, path=%p, connection=%p\n", (void *)node,
449 	    (void *)path, (void *)connection);
450 
451 	if ((node == NULL) || (path == NULL) || (connection == NULL)) {
452 		i_hp_dprintf("hp_path: invalid arguments.\n");
453 		return (EINVAL);
454 	}
455 
456 	(void) memset(path, 0, MAXPATHLEN);
457 	(void) memset(connection, 0, MAXPATHLEN);
458 	(void) memset(components, 0, MAXPATHLEN);
459 
460 	/*  Set 'connection' only for connectors and ports */
461 	if ((node->hp_type == HP_NODE_CONNECTOR) ||
462 	    (node->hp_type == HP_NODE_PORT))
463 		(void) strlcpy(connection, node->hp_name, MAXPATHLEN);
464 
465 	/* Trace back to the root node, accumulating components */
466 	for (parent = node; parent != NULL; parent = parent->hp_parent) {
467 		if (parent->hp_type == HP_NODE_DEVICE) {
468 			(void) strlcat(components, "/", MAXPATHLEN);
469 			(void) strlcat(components, parent->hp_name, MAXPATHLEN);
470 		}
471 		if (parent->hp_parent == NULL)
472 			root = parent;
473 	}
474 
475 	/* Ensure the snapshot actually contains a base path */
476 	if (root->hp_basepath == NULL) {
477 		i_hp_dprintf("hp_path: missing base pathname.\n");
478 		return (EFAULT);
479 	}
480 
481 	/*
482 	 * Construct the path.  Start with the base path from the root
483 	 * node, then append the accumulated components in reverse order.
484 	 */
485 	if (strcmp(root->hp_basepath, "/") != 0) {
486 		(void) strlcat(path, root->hp_basepath, MAXPATHLEN);
487 		if ((root->hp_type == HP_NODE_DEVICE) &&
488 		    ((s = strrchr(path, '/')) != NULL))
489 			*s = '\0';
490 	}
491 	for (i = strlen(components) - 1; i >= 0; i--) {
492 		if (components[i] == '/') {
493 			(void) strlcat(path, &components[i], MAXPATHLEN);
494 			components[i] = '\0';
495 		}
496 	}
497 
498 	return (0);
499 }
500 
501 /*
502  * hp_set_state()
503  *
504  *	Initiate a state change operation on a node.
505  */
506 int
hp_set_state(hp_node_t node,uint_t flags,int state,hp_node_t * resultsp)507 hp_set_state(hp_node_t node, uint_t flags, int state, hp_node_t *resultsp)
508 {
509 	hp_node_t	root = NULL;
510 	nvlist_t	*args;
511 	nvlist_t	*results;
512 	int		rv;
513 	char		path[MAXPATHLEN];
514 	char		connection[MAXPATHLEN];
515 
516 	i_hp_dprintf("hp_set_state: node=%p, flags=0x%x, state=0x%x, "
517 	    "resultsp=%p\n", (void *)node, flags, state, (void *)resultsp);
518 
519 	/* Check arguments */
520 	if ((node == NULL) || (resultsp == NULL) ||
521 	    !HP_SET_STATE_FLAGS_VALID(flags)) {
522 		i_hp_dprintf("hp_set_state: invalid arguments.\n");
523 		return (EINVAL);
524 	}
525 
526 	/* Check node type */
527 	if ((node->hp_type != HP_NODE_CONNECTOR) &&
528 	    (node->hp_type != HP_NODE_PORT)) {
529 		i_hp_dprintf("hp_set_state: operation not supported.\n");
530 		return (ENOTSUP);
531 	}
532 
533 	/* Check that target state is valid */
534 	switch (state) {
535 	case DDI_HP_CN_STATE_PRESENT:
536 	case DDI_HP_CN_STATE_POWERED:
537 	case DDI_HP_CN_STATE_ENABLED:
538 		if (node->hp_type != HP_NODE_CONNECTOR) {
539 			i_hp_dprintf("hp_set_state: mismatched target.\n");
540 			return (ENOTSUP);
541 		}
542 		break;
543 	case DDI_HP_CN_STATE_PORT_PRESENT:
544 	case DDI_HP_CN_STATE_OFFLINE:
545 	case DDI_HP_CN_STATE_ONLINE:
546 		if (node->hp_type != HP_NODE_PORT) {
547 			i_hp_dprintf("hp_set_state: mismatched target.\n");
548 			return (ENOTSUP);
549 		}
550 		break;
551 	default:
552 		i_hp_dprintf("hp_set_state: invalid target state.\n");
553 		return (EINVAL);
554 	}
555 
556 	/* Get path and connection of specified node */
557 	if ((rv = hp_path(node, path, connection)) != 0)
558 		return (rv);
559 
560 	/* Build arguments for door call */
561 	if ((args = i_hp_set_args(HP_CMD_CHANGESTATE, path, connection, flags,
562 	    NULL, state)) == NULL)
563 		return (ENOMEM);
564 
565 	/* Make the door call to hotplugd */
566 	rv = i_hp_call_hotplugd(args, &results);
567 
568 	/* Arguments no longer needed */
569 	nvlist_free(args);
570 
571 	/* Parse additional results, if any */
572 	if ((rv == 0) && (results != NULL)) {
573 		rv = i_hp_parse_results(results, &root, NULL);
574 		nvlist_free(results);
575 		*resultsp = root;
576 	}
577 
578 	/* Done */
579 	return (rv);
580 }
581 
582 /*
583  * hp_set_private()
584  *
585  *	Set bus private options on the hotplug connection
586  *	indicated by the given hotplug information node.
587  */
588 int
hp_set_private(hp_node_t node,const char * options,char ** resultsp)589 hp_set_private(hp_node_t node, const char *options, char **resultsp)
590 {
591 	int		rv;
592 	nvlist_t	*args;
593 	nvlist_t	*results;
594 	char		*values = NULL;
595 	char		path[MAXPATHLEN];
596 	char		connection[MAXPATHLEN];
597 
598 	i_hp_dprintf("hp_set_private: node=%p, options=%p, resultsp=%p\n",
599 	    (void *)node, (void *)options, (void *)resultsp);
600 
601 	/* Check arguments */
602 	if ((node == NULL) || (options == NULL) || (resultsp == NULL)) {
603 		i_hp_dprintf("hp_set_private: invalid arguments.\n");
604 		return (EINVAL);
605 	}
606 
607 	/* Check node type */
608 	if (node->hp_type != HP_NODE_CONNECTOR) {
609 		i_hp_dprintf("hp_set_private: operation not supported.\n");
610 		return (ENOTSUP);
611 	}
612 
613 	/* Initialize results */
614 	*resultsp = NULL;
615 
616 	/* Get path and connection of specified node */
617 	if ((rv = hp_path(node, path, connection)) != 0)
618 		return (rv);
619 
620 	/* Build arguments for door call */
621 	if ((args = i_hp_set_args(HP_CMD_SETPRIVATE, path, connection, 0,
622 	    options, 0)) == NULL)
623 		return (ENOMEM);
624 
625 	/* Make the door call to hotplugd */
626 	rv = i_hp_call_hotplugd(args, &results);
627 
628 	/* Arguments no longer needed */
629 	nvlist_free(args);
630 
631 	/* Parse additional results, if any */
632 	if ((rv == 0) && (results != NULL)) {
633 		rv = i_hp_parse_results(results, NULL, &values);
634 		nvlist_free(results);
635 		*resultsp = values;
636 	}
637 
638 	/* Done */
639 	return (rv);
640 }
641 
642 /*
643  * hp_get_private()
644  *
645  *	Get bus private options on the hotplug connection
646  *	indicated by the given hotplug information node.
647  */
648 int
hp_get_private(hp_node_t node,const char * options,char ** resultsp)649 hp_get_private(hp_node_t node, const char *options, char **resultsp)
650 {
651 	int		rv;
652 	nvlist_t	*args;
653 	nvlist_t	*results;
654 	char		*values = NULL;
655 	char		path[MAXPATHLEN];
656 	char		connection[MAXPATHLEN];
657 
658 	i_hp_dprintf("hp_get_private: node=%p, options=%p, resultsp=%p\n",
659 	    (void *)node, (void *)options, (void *)resultsp);
660 
661 	/* Check arguments */
662 	if ((node == NULL) || (options == NULL) || (resultsp == NULL)) {
663 		i_hp_dprintf("hp_get_private: invalid arguments.\n");
664 		return (EINVAL);
665 	}
666 
667 	/* Check node type */
668 	if (node->hp_type != HP_NODE_CONNECTOR) {
669 		i_hp_dprintf("hp_get_private: operation not supported.\n");
670 		return (ENOTSUP);
671 	}
672 
673 	/* Initialize results */
674 	*resultsp = NULL;
675 
676 	/* Get path and connection of specified node */
677 	if ((rv = hp_path(node, path, connection)) != 0)
678 		return (rv);
679 
680 	/* Build arguments for door call */
681 	if ((args = i_hp_set_args(HP_CMD_GETPRIVATE, path, connection, 0,
682 	    options, 0)) == NULL)
683 		return (ENOMEM);
684 
685 	/* Make the door call to hotplugd */
686 	rv = i_hp_call_hotplugd(args, &results);
687 
688 	/* Arguments no longer needed */
689 	nvlist_free(args);
690 
691 	/* Parse additional results, if any */
692 	if ((rv == 0) && (results != NULL)) {
693 		rv = i_hp_parse_results(results, NULL, &values);
694 		nvlist_free(results);
695 		*resultsp = values;
696 	}
697 
698 	/* Done */
699 	return (rv);
700 }
701 
702 /*
703  * hp_pack()
704  *
705  *	Given the root of a hotplug information snapshot, pack
706  *	it into a contiguous byte array so that it is suitable
707  *	for network transport.
708  */
709 int
hp_pack(hp_node_t root,char ** bufp,size_t * lenp)710 hp_pack(hp_node_t root, char **bufp, size_t *lenp)
711 {
712 	hp_node_t	node;
713 	nvlist_t	*nvl;
714 	char		*buf;
715 	size_t		len;
716 	int		rv;
717 
718 	i_hp_dprintf("hp_pack: root=%p, bufp=%p, lenp=%p\n", (void *)root,
719 	    (void *)bufp, (void *)lenp);
720 
721 	if ((root == NULL) || (bufp == NULL) || (lenp == NULL)) {
722 		i_hp_dprintf("hp_pack: invalid arguments.\n");
723 		return (EINVAL);
724 	}
725 
726 	*lenp = 0;
727 	*bufp = NULL;
728 
729 	if (nvlist_alloc(&nvl, 0, 0) != 0) {
730 		i_hp_dprintf("hp_pack: nvlist_alloc() failed (%s).\n",
731 		    strerror(errno));
732 		return (ENOMEM);
733 	}
734 
735 	if (root->hp_basepath != NULL) {
736 		rv = nvlist_add_string(nvl, HP_INFO_BASE, root->hp_basepath);
737 		if (rv != 0) {
738 			nvlist_free(nvl);
739 			return (rv);
740 		}
741 	}
742 
743 	for (node = root; node != NULL; node = node->hp_sibling) {
744 		if ((rv = i_hp_pack_branch(node, &buf, &len)) == 0) {
745 			rv = nvlist_add_byte_array(nvl, HP_INFO_BRANCH,
746 			    (uchar_t *)buf, len);
747 			free(buf);
748 		}
749 		if (rv != 0) {
750 			nvlist_free(nvl);
751 			return (rv);
752 		}
753 	}
754 
755 	len = 0;
756 	buf = NULL;
757 	if ((rv = nvlist_pack(nvl, &buf, &len, NV_ENCODE_NATIVE, 0)) == 0) {
758 		*lenp = len;
759 		*bufp = buf;
760 	}
761 
762 	nvlist_free(nvl);
763 
764 	return (rv);
765 }
766 
767 /*
768  * hp_unpack()
769  *
770  *	Unpack a hotplug information snapshot for normal usage.
771  */
772 int
hp_unpack(char * packed_buf,size_t packed_len,hp_node_t * retp)773 hp_unpack(char *packed_buf, size_t packed_len, hp_node_t *retp)
774 {
775 	hp_node_t	root;
776 	hp_node_t	root_list = NULL;
777 	hp_node_t	prev_root = NULL;
778 	nvlist_t	*nvl = NULL;
779 	nvpair_t	*nvp;
780 	char		*basepath = NULL;
781 	int		rv;
782 
783 	i_hp_dprintf("hp_unpack: packed_buf=%p, packed_len=%u, retp=%p\n",
784 	    (void *)packed_buf, (uint32_t)packed_len, (void *)retp);
785 
786 	if ((packed_buf == NULL) || (packed_len == 0) || (retp == NULL)) {
787 		i_hp_dprintf("hp_unpack: invalid arguments.\n");
788 		return (EINVAL);
789 	}
790 
791 	if ((rv = nvlist_unpack(packed_buf, packed_len, &nvl, 0)) != 0)
792 		return (rv);
793 
794 	if (nvlist_next_nvpair(nvl, NULL) == NULL) {
795 		nvlist_free(nvl);
796 		errno = EINVAL;
797 		return (NULL);
798 	}
799 
800 	for (nvp = NULL; nvp = nvlist_next_nvpair(nvl, nvp); ) {
801 
802 		rv = EINVAL;
803 
804 		if (strcmp(nvpair_name(nvp), HP_INFO_BASE) == 0) {
805 			char	*val_string;
806 
807 			if ((rv = nvpair_value_string(nvp, &val_string)) == 0) {
808 				if ((basepath = strdup(val_string)) == NULL)
809 					rv = ENOMEM;
810 			}
811 
812 		} else if (strcmp(nvpair_name(nvp), HP_INFO_BRANCH) == 0) {
813 			size_t		len = 0;
814 			char		*buf = NULL;
815 
816 			if ((rv = nvpair_value_byte_array(nvp,
817 			    (uchar_t **)&buf, (uint_t *)&len)) == 0) {
818 				rv = i_hp_unpack_branch(buf, len, NULL, &root);
819 			}
820 
821 			if (rv == 0) {
822 				if (prev_root) {
823 					prev_root->hp_sibling = root;
824 				} else {
825 					root_list = root;
826 				}
827 				prev_root = root;
828 			}
829 		}
830 
831 		if (rv != 0) {
832 			if (basepath)
833 				free(basepath);
834 			nvlist_free(nvl);
835 			hp_fini(root_list);
836 			*retp = NULL;
837 			return (rv);
838 		}
839 	}
840 
841 	/* Store the base path in each root node */
842 	if (basepath) {
843 		for (root = root_list; root; root = root->hp_sibling)
844 			root->hp_basepath = basepath;
845 	}
846 
847 	nvlist_free(nvl);
848 	*retp = root_list;
849 	return (0);
850 }
851 
852 /*
853  * i_hp_dprintf()
854  *
855  *	Print debug messages to stderr, but only when the debug flag
856  *	(libhotplug_debug) is set.
857  */
858 /*PRINTFLIKE1*/
859 static void
i_hp_dprintf(const char * fmt,...)860 i_hp_dprintf(const char *fmt, ...)
861 {
862 	va_list	ap;
863 
864 	if (libhotplug_debug) {
865 		va_start(ap, fmt);
866 		(void) vfprintf(stderr, fmt, ap);
867 		va_end(ap);
868 	}
869 }
870 
871 /*
872  * i_hp_pack_branch()
873  *
874  *	Pack an individual branch of a hotplug information snapshot.
875  */
876 static int
i_hp_pack_branch(hp_node_t root,char ** bufp,size_t * lenp)877 i_hp_pack_branch(hp_node_t root, char **bufp, size_t *lenp)
878 {
879 	hp_node_t	child;
880 	nvlist_t	*nvl;
881 	char		*buf;
882 	size_t		len;
883 	int		rv;
884 
885 	*lenp = 0;
886 	*bufp = NULL;
887 
888 	/* Allocate an nvlist for this branch */
889 	if (nvlist_alloc(&nvl, 0, 0) != 0)
890 		return (ENOMEM);
891 
892 	/* Pack the root of the branch and add it to the nvlist */
893 	if ((rv = i_hp_pack_node(root, &buf, &len)) == 0) {
894 		rv = nvlist_add_byte_array(nvl, HP_INFO_NODE,
895 		    (uchar_t *)buf, len);
896 		free(buf);
897 	}
898 	if (rv != 0) {
899 		nvlist_free(nvl);
900 		return (rv);
901 	}
902 
903 	/* Pack each subordinate branch, and add it to the nvlist */
904 	for (child = root->hp_child; child != NULL; child = child->hp_sibling) {
905 		if ((rv = i_hp_pack_branch(child, &buf, &len)) == 0) {
906 			rv = nvlist_add_byte_array(nvl, HP_INFO_BRANCH,
907 			    (uchar_t *)buf, len);
908 			free(buf);
909 		}
910 		if (rv != 0) {
911 			nvlist_free(nvl);
912 			return (rv);
913 		}
914 	}
915 
916 	/* Pack the resulting nvlist into a single buffer */
917 	len = 0;
918 	buf = NULL;
919 	if ((rv = nvlist_pack(nvl, &buf, &len, NV_ENCODE_NATIVE, 0)) == 0) {
920 		*lenp = len;
921 		*bufp = buf;
922 	}
923 
924 	/* Free the nvlist */
925 	nvlist_free(nvl);
926 
927 	return (rv);
928 }
929 
930 /*
931  * i_hp_pack_node()
932  *
933  *	Pack an individual node of a hotplug information snapshot.
934  */
935 static int
i_hp_pack_node(hp_node_t node,char ** bufp,size_t * lenp)936 i_hp_pack_node(hp_node_t node, char **bufp, size_t *lenp)
937 {
938 	nvlist_t	*nvl;
939 	char		*buf = NULL;
940 	size_t		len = 0;
941 	int		rv;
942 
943 	if (nvlist_alloc(&nvl, 0, 0) != 0)
944 		return (ENOMEM);
945 
946 	if ((rv = nvlist_add_uint32(nvl, HP_INFO_TYPE,
947 	    (uint32_t)node->hp_type)) != 0)
948 		goto fail;
949 
950 	if ((node->hp_name) &&
951 	    ((rv = nvlist_add_string(nvl, HP_INFO_NAME, node->hp_name)) != 0))
952 		goto fail;
953 
954 	if ((node->hp_usage) &&
955 	    ((rv = nvlist_add_string(nvl, HP_INFO_USAGE, node->hp_usage)) != 0))
956 		goto fail;
957 
958 	if ((node->hp_description) &&
959 	    ((rv = nvlist_add_string(nvl, HP_INFO_DESC,
960 	    node->hp_description)) != 0))
961 		goto fail;
962 
963 	if ((rv = nvlist_add_uint32(nvl, HP_INFO_STATE, node->hp_state)) != 0)
964 		goto fail;
965 
966 	if ((node->hp_last_change != 0) &&
967 	    ((rv = nvlist_add_uint32(nvl, HP_INFO_TIME,
968 	    node->hp_last_change)) != 0))
969 		goto fail;
970 
971 	if ((rv = nvlist_pack(nvl, &buf, &len, NV_ENCODE_NATIVE, 0)) != 0)
972 		goto fail;
973 
974 	*bufp = buf;
975 	*lenp = len;
976 	nvlist_free(nvl);
977 	return (0);
978 
979 fail:
980 	*bufp = NULL;
981 	*lenp = 0;
982 	nvlist_free(nvl);
983 	return (rv);
984 }
985 
986 /*
987  * i_hp_unpack_branch()
988  *
989  *	Unpack a branch of hotplug information nodes.
990  */
991 static int
i_hp_unpack_branch(char * packed_buf,size_t packed_len,hp_node_t parent,hp_node_t * retp)992 i_hp_unpack_branch(char *packed_buf, size_t packed_len, hp_node_t parent,
993     hp_node_t *retp)
994 {
995 	hp_node_t	node = NULL;
996 	hp_node_t	child;
997 	hp_node_t	prev_child = NULL;
998 	nvlist_t	*nvl = NULL;
999 	nvpair_t	*nvp;
1000 	char		*buf;
1001 	size_t		len;
1002 	int		rv;
1003 
1004 	/* Initialize results */
1005 	*retp = NULL;
1006 
1007 	/* Unpack the nvlist for this branch */
1008 	if ((rv = nvlist_unpack(packed_buf, packed_len, &nvl, 0)) != 0)
1009 		return (rv);
1010 
1011 	/*
1012 	 * Unpack the branch.  The first item in the nvlist is
1013 	 * always the root node.  And zero or more subordinate
1014 	 * branches may be packed afterward.
1015 	 */
1016 	for (nvp = NULL; nvp = nvlist_next_nvpair(nvl, nvp); ) {
1017 
1018 		len = 0;
1019 		buf = NULL;
1020 
1021 		if (strcmp(nvpair_name(nvp), HP_INFO_NODE) == 0) {
1022 
1023 			/* Check that there is only one root node */
1024 			if (node != NULL) {
1025 				hp_fini(node);
1026 				nvlist_free(nvl);
1027 				return (EFAULT);
1028 			}
1029 
1030 			if ((rv = nvpair_value_byte_array(nvp, (uchar_t **)&buf,
1031 			    (uint_t *)&len)) == 0)
1032 				rv = i_hp_unpack_node(buf, len, parent, &node);
1033 
1034 			if (rv != 0) {
1035 				nvlist_free(nvl);
1036 				return (rv);
1037 			}
1038 
1039 		} else if (strcmp(nvpair_name(nvp), HP_INFO_BRANCH) == 0) {
1040 
1041 			if ((rv = nvpair_value_byte_array(nvp, (uchar_t **)&buf,
1042 			    (uint_t *)&len)) == 0)
1043 				rv = i_hp_unpack_branch(buf, len, node, &child);
1044 
1045 			if (rv != 0) {
1046 				hp_fini(node);
1047 				nvlist_free(nvl);
1048 				return (rv);
1049 			}
1050 
1051 			if (prev_child) {
1052 				prev_child->hp_sibling = child;
1053 			} else {
1054 				node->hp_child = child;
1055 			}
1056 			prev_child = child;
1057 		}
1058 	}
1059 
1060 	nvlist_free(nvl);
1061 	*retp = node;
1062 	return (0);
1063 }
1064 
1065 /*
1066  * i_hp_unpack_node()
1067  *
1068  *	Unpack an individual hotplug information node.
1069  */
1070 static int
i_hp_unpack_node(char * buf,size_t len,hp_node_t parent,hp_node_t * retp)1071 i_hp_unpack_node(char *buf, size_t len, hp_node_t parent, hp_node_t *retp)
1072 {
1073 	hp_node_t	node;
1074 	nvlist_t	*nvl;
1075 	nvpair_t	*nvp;
1076 	uint32_t	val_uint32;
1077 	char		*val_string;
1078 	int		rv = 0;
1079 
1080 	/* Initialize results */
1081 	*retp = NULL;
1082 
1083 	/* Unpack node into an nvlist */
1084 	if ((nvlist_unpack(buf, len, &nvl, 0) != 0))
1085 		return (EINVAL);
1086 
1087 	/* Allocate the new node */
1088 	if ((node = (hp_node_t)calloc(1, sizeof (struct hp_node))) == NULL) {
1089 		nvlist_free(nvl);
1090 		return (ENOMEM);
1091 	}
1092 
1093 	/* Iterate through nvlist, unpacking each field */
1094 	for (nvp = NULL; nvp = nvlist_next_nvpair(nvl, nvp); ) {
1095 
1096 		if ((strcmp(nvpair_name(nvp), HP_INFO_TYPE) == 0) &&
1097 		    (nvpair_type(nvp) == DATA_TYPE_UINT32)) {
1098 
1099 			(void) nvpair_value_uint32(nvp, &val_uint32);
1100 			node->hp_type = val_uint32;
1101 
1102 		} else if ((strcmp(nvpair_name(nvp), HP_INFO_NAME) == 0) &&
1103 		    (nvpair_type(nvp) == DATA_TYPE_STRING)) {
1104 
1105 			(void) nvpair_value_string(nvp, &val_string);
1106 			if ((node->hp_name = strdup(val_string)) == NULL) {
1107 				rv = ENOMEM;
1108 				break;
1109 			}
1110 
1111 		} else if ((strcmp(nvpair_name(nvp), HP_INFO_STATE) == 0) &&
1112 		    (nvpair_type(nvp) == DATA_TYPE_UINT32)) {
1113 
1114 			(void) nvpair_value_uint32(nvp, &val_uint32);
1115 			node->hp_state = val_uint32;
1116 
1117 		} else if ((strcmp(nvpair_name(nvp), HP_INFO_USAGE) == 0) &&
1118 		    (nvpair_type(nvp) == DATA_TYPE_STRING)) {
1119 
1120 			(void) nvpair_value_string(nvp, &val_string);
1121 			if ((node->hp_usage = strdup(val_string)) == NULL) {
1122 				rv = ENOMEM;
1123 				break;
1124 			}
1125 
1126 		} else if ((strcmp(nvpair_name(nvp), HP_INFO_DESC) == 0) &&
1127 		    (nvpair_type(nvp) == DATA_TYPE_STRING)) {
1128 
1129 			(void) nvpair_value_string(nvp, &val_string);
1130 			if ((node->hp_description = strdup(val_string))
1131 			    == NULL) {
1132 				rv = ENOMEM;
1133 				break;
1134 			}
1135 
1136 		} else if ((strcmp(nvpair_name(nvp), HP_INFO_TIME) == 0) &&
1137 		    (nvpair_type(nvp) == DATA_TYPE_UINT32)) {
1138 
1139 			(void) nvpair_value_uint32(nvp, &val_uint32);
1140 			node->hp_last_change = (time_t)val_uint32;
1141 
1142 		} else {
1143 			i_hp_dprintf("i_hp_unpack_node: unrecognized: '%s'\n",
1144 			    nvpair_name(nvp));
1145 		}
1146 	}
1147 
1148 	/* Unpacked nvlist no longer needed */
1149 	nvlist_free(nvl);
1150 
1151 	/* Check for errors */
1152 	if (rv != 0) {
1153 		hp_fini(node);
1154 		return (rv);
1155 	}
1156 
1157 	/* Success */
1158 	node->hp_parent = parent;
1159 	*retp = node;
1160 	return (0);
1161 }
1162 
1163 /*
1164  * i_hp_call_hotplugd()
1165  *
1166  *	Perform a door call to the hotplug daemon.
1167  */
1168 static int
i_hp_call_hotplugd(nvlist_t * args,nvlist_t ** resultsp)1169 i_hp_call_hotplugd(nvlist_t *args, nvlist_t **resultsp)
1170 {
1171 	door_arg_t	door_arg;
1172 	nvlist_t	*results = NULL;
1173 	char		*buf = NULL;
1174 	size_t		len = 0;
1175 	uint64_t	seqnum;
1176 	int		door_fd;
1177 	int		rv;
1178 
1179 	/* Initialize results */
1180 	*resultsp = NULL;
1181 
1182 	/* Open door */
1183 	if ((door_fd = open(HOTPLUGD_DOOR, O_RDONLY)) < 0) {
1184 		i_hp_dprintf("i_hp_call_hotplugd: cannot open door (%s)\n",
1185 		    strerror(errno));
1186 		return (EBADF);
1187 	}
1188 
1189 	/* Pack the nvlist of arguments */
1190 	if ((rv = nvlist_pack(args, &buf, &len, NV_ENCODE_NATIVE, 0)) != 0) {
1191 		i_hp_dprintf("i_hp_call_hotplugd: cannot pack arguments (%s)\n",
1192 		    strerror(rv));
1193 		return (rv);
1194 	}
1195 
1196 	/* Set the door argument using the packed arguments */
1197 	door_arg.data_ptr = buf;
1198 	door_arg.data_size = len;
1199 	door_arg.desc_ptr = NULL;
1200 	door_arg.desc_num = 0;
1201 	door_arg.rbuf = (char *)(uintptr_t)&rv;
1202 	door_arg.rsize = sizeof (rv);
1203 
1204 	/* Attempt the door call */
1205 	if (door_call(door_fd, &door_arg) != 0) {
1206 		rv = errno;
1207 		i_hp_dprintf("i_hp_call_hotplugd: door call failed (%s)\n",
1208 		    strerror(rv));
1209 		(void) close(door_fd);
1210 		free(buf);
1211 		return (rv);
1212 	}
1213 
1214 	/* The arguments are no longer needed */
1215 	free(buf);
1216 
1217 	/*
1218 	 * If results are not in the original buffer provided,
1219 	 * then check and process the new results buffer.
1220 	 */
1221 	if (door_arg.rbuf != (char *)(uintptr_t)&rv) {
1222 
1223 		/*
1224 		 * First check that the buffer is valid.  Then check for
1225 		 * the simple case where a short result code was sent.
1226 		 * The last case is a packed nvlist was returned, which
1227 		 * needs to be unpacked.
1228 		 */
1229 		if ((door_arg.rbuf == NULL) ||
1230 		    (door_arg.data_size < sizeof (rv))) {
1231 			i_hp_dprintf("i_hp_call_hotplugd: invalid results.\n");
1232 			rv = EFAULT;
1233 
1234 		} else if (door_arg.data_size == sizeof (rv)) {
1235 			rv = *(int *)(uintptr_t)door_arg.rbuf;
1236 
1237 		} else if ((rv = nvlist_unpack(door_arg.rbuf,
1238 		    door_arg.data_size, &results, 0)) != 0) {
1239 			i_hp_dprintf("i_hp_call_hotplugd: "
1240 			    "cannot unpack results (%s).\n", strerror(rv));
1241 			results = NULL;
1242 			rv = EFAULT;
1243 		}
1244 
1245 		/* Unmap the results buffer */
1246 		if (door_arg.rbuf != NULL)
1247 			(void) munmap(door_arg.rbuf, door_arg.rsize);
1248 
1249 		/*
1250 		 * In the case of a packed nvlist, notify the daemon
1251 		 * that it can free the result buffer from its heap.
1252 		 */
1253 		if ((results != NULL) &&
1254 		    (nvlist_lookup_uint64(results, HPD_SEQNUM, &seqnum) == 0)) {
1255 			door_arg.data_ptr = (char *)(uintptr_t)&seqnum;
1256 			door_arg.data_size = sizeof (seqnum);
1257 			door_arg.desc_ptr = NULL;
1258 			door_arg.desc_num = 0;
1259 			door_arg.rbuf = NULL;
1260 			door_arg.rsize = 0;
1261 			(void) door_call(door_fd, &door_arg);
1262 			if (door_arg.rbuf != NULL)
1263 				(void) munmap(door_arg.rbuf, door_arg.rsize);
1264 		}
1265 
1266 		*resultsp = results;
1267 	}
1268 
1269 	(void) close(door_fd);
1270 	return (rv);
1271 }
1272 
1273 /*
1274  * i_hp_set_args()
1275  *
1276  *	Construct an nvlist of arguments for a hotplugd door call.
1277  */
1278 static nvlist_t *
i_hp_set_args(hp_cmd_t cmd,const char * path,const char * connection,uint_t flags,const char * options,int state)1279 i_hp_set_args(hp_cmd_t cmd, const char *path, const char *connection,
1280     uint_t flags, const char *options, int state)
1281 {
1282 	nvlist_t	*args;
1283 
1284 	/* Allocate a new nvlist */
1285 	if (nvlist_alloc(&args, NV_UNIQUE_NAME_TYPE, 0) != 0)
1286 		return (NULL);
1287 
1288 	/* Add common arguments */
1289 	if ((nvlist_add_int32(args, HPD_CMD, cmd) != 0) ||
1290 	    (nvlist_add_string(args, HPD_PATH, path) != 0)) {
1291 		nvlist_free(args);
1292 		return (NULL);
1293 	}
1294 
1295 	/* Add connection, but only if defined */
1296 	if ((connection != NULL) && (connection[0] != '\0') &&
1297 	    (nvlist_add_string(args, HPD_CONNECTION, connection) != 0)) {
1298 		nvlist_free(args);
1299 		return (NULL);
1300 	}
1301 
1302 	/* Add flags, but only if defined */
1303 	if ((flags != 0) && (nvlist_add_uint32(args, HPD_FLAGS, flags) != 0)) {
1304 		nvlist_free(args);
1305 		return (NULL);
1306 	}
1307 
1308 	/* Add options, but only if defined */
1309 	if ((options != NULL) &&
1310 	    (nvlist_add_string(args, HPD_OPTIONS, options) != 0)) {
1311 		nvlist_free(args);
1312 		return (NULL);
1313 	}
1314 
1315 	/* Add state, but only for CHANGESTATE command */
1316 	if ((cmd == HP_CMD_CHANGESTATE) &&
1317 	    (nvlist_add_int32(args, HPD_STATE, state) != 0)) {
1318 		nvlist_free(args);
1319 		return (NULL);
1320 	}
1321 
1322 	return (args);
1323 }
1324 
1325 /*
1326  * i_hp_parse_results()
1327  *
1328  *	Parse out individual fields of an nvlist of results from
1329  *	a hotplugd door call.
1330  */
1331 static int
i_hp_parse_results(nvlist_t * results,hp_node_t * rootp,char ** optionsp)1332 i_hp_parse_results(nvlist_t *results, hp_node_t *rootp, char **optionsp)
1333 {
1334 	int	rv;
1335 
1336 	/* Parse an information snapshot */
1337 	if (rootp) {
1338 		char	*buf = NULL;
1339 		size_t	len = 0;
1340 
1341 		*rootp = NULL;
1342 		if (nvlist_lookup_byte_array(results, HPD_INFO,
1343 		    (uchar_t **)&buf, (uint_t *)&len) == 0) {
1344 			if ((rv = hp_unpack(buf, len, rootp)) != 0)
1345 				return (rv);
1346 		}
1347 	}
1348 
1349 	/* Parse a bus private option string */
1350 	if (optionsp) {
1351 		char	*str;
1352 
1353 		*optionsp = NULL;
1354 		if ((nvlist_lookup_string(results, HPD_OPTIONS, &str) == 0) &&
1355 		    ((*optionsp = strdup(str)) == NULL)) {
1356 			return (ENOMEM);
1357 		}
1358 	}
1359 
1360 	/* Parse result code of the operation */
1361 	if (nvlist_lookup_int32(results, HPD_STATUS, &rv) != 0) {
1362 		i_hp_dprintf("i_hp_call_hotplugd: missing status.\n");
1363 		return (EFAULT);
1364 	}
1365 
1366 	return (rv);
1367 }
1368