usr/src/lib/libhotplug/common/libhotplug.c

   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
  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
 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
 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
 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 *
 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
 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 *
 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 *
 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
 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
 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
 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
 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
 440 hp_path(hp_node_t node, char *path, char *connection)
 441 {
 442         hp_node_t       root = NULL;
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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 *
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
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 }