Print this page
patch tsoome-feedback


   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 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27 
  28 /*
  29  * Routines for traversing and packing/unpacking the handle
  30  * returned from ri_init.
  31  */
  32 
  33 #include <stdlib.h>
  34 #include <strings.h>
  35 #include "rsrc_info.h"
  36 #include "rsrc_info_impl.h"
  37 
  38 static int ap_list_pack(ri_ap_t *, char **, size_t *, int);
  39 static int ap_list_unpack(char *, size_t, ri_ap_t **);
  40 static int ap_pack(ri_ap_t *, char **, size_t *, int);
  41 static int ap_unpack(char *, size_t, ri_ap_t *);
  42 static int dev_list_pack(ri_dev_t *, char **, size_t *, int);
  43 static int dev_list_unpack(char *, size_t, ri_dev_t **);
  44 static int dev_pack(ri_dev_t *, char **, size_t *, int);
  45 static int dev_unpack(char *, size_t, ri_dev_t *);
  46 static int client_list_pack(ri_client_t *, char **, size_t *, int);
  47 static int client_list_unpack(char *, size_t, ri_client_t **);


  65                 ri_ap_free(ap);
  66         }
  67         while ((client = hdl->cpu_cap_clients) != NULL) {
  68                 hdl->cpu_cap_clients = client->next;
  69                 ri_client_free(client);
  70         }
  71         while ((client = hdl->mem_cap_clients) != NULL) {
  72                 hdl->mem_cap_clients = client->next;
  73                 ri_client_free(client);
  74         }
  75         free(hdl);
  76 }
  77 
  78 static void
  79 ri_ap_free(ri_ap_t *ap)
  80 {
  81         ri_dev_t        *dev;
  82 
  83         assert(ap != NULL);
  84 
  85         if (ap->conf_props != NULL)
  86                 nvlist_free(ap->conf_props);
  87 
  88         while ((dev = ap->cpus) != NULL) {
  89                 ap->cpus = dev->next;
  90                 ri_dev_free(dev);
  91         }
  92         while ((dev = ap->mems) != NULL) {
  93                 ap->mems = dev->next;
  94                 ri_dev_free(dev);
  95         }
  96         while ((dev = ap->ios) != NULL) {
  97                 ap->ios = dev->next;
  98                 ri_dev_free(dev);
  99         }
 100         free(ap);
 101 }
 102 
 103 void
 104 ri_dev_free(ri_dev_t *dev)
 105 {
 106         ri_client_t     *client;
 107 
 108         assert(dev != NULL);
 109 
 110         nvlist_free(dev->conf_props);
 111         while ((client = dev->rcm_clients) != NULL) {
 112                 dev->rcm_clients = client->next;
 113                 ri_client_free(client);
 114         }
 115         free(dev);
 116 }
 117 
 118 void
 119 ri_client_free(ri_client_t *client)
 120 {
 121         assert(client != NULL);
 122 
 123         if (client->usg_props != NULL)
 124                 nvlist_free(client->usg_props);
 125         if (client->v_props != NULL)
 126                 nvlist_free(client->v_props);
 127         free(client);
 128 }
 129 
 130 /*
 131  * Pack everything contained in the handle up inside out.
 132  */
 133 int
 134 ri_pack(ri_hdl_t *hdl, caddr_t *bufp, size_t *sizep, int encoding)
 135 {
 136         nvlist_t        *nvl = NULL;
 137         char            *buf = NULL;
 138         size_t          size = 0;
 139 
 140         if (bufp == NULL || sizep == NULL)
 141                 return (RI_INVAL);
 142 
 143         *sizep = 0;
 144         *bufp = NULL;
 145 


 179             encoding) != 0 ||
 180             nvlist_add_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t *)buf,
 181             size) != 0) {
 182                 goto fail;
 183         }
 184 
 185         s_free(buf);
 186         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 187                 dprintf((stderr, "nvlist_pack fail\n"));
 188                 goto fail;
 189         }
 190 
 191         nvlist_free(nvl);
 192         *bufp = buf;
 193         *sizep = size;
 194 
 195         return (RI_SUCCESS);
 196 
 197 fail:
 198         s_free(buf);
 199         if (nvl != NULL)
 200                 nvlist_free(nvl);
 201 
 202         return (RI_FAILURE);
 203 }
 204 
 205 /*
 206  * Pack a list of attachment point handles.
 207  */
 208 static int
 209 ap_list_pack(ri_ap_t *aplist, char **bufp, size_t *sizep, int encoding)
 210 {
 211         nvlist_t        *nvl = NULL;
 212         char            *buf = NULL;
 213         size_t          size;
 214 
 215         assert(bufp != NULL && sizep != NULL);
 216 
 217         *sizep = 0;
 218         *bufp = NULL;
 219 


 233                             "(%s)\n", RI_AP_T));
 234                         goto fail;
 235                 }
 236                 aplist = aplist->next;
 237         }
 238 
 239         s_free(buf);
 240         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 241                 dprintf((stderr, "nvlist_pack fail\n"));
 242                 goto fail;
 243         }
 244 
 245         nvlist_free(nvl);
 246         *bufp = buf;
 247         *sizep = size;
 248 
 249         return (0);
 250 
 251 fail:
 252         s_free(buf);
 253         if (nvl != NULL)
 254                 nvlist_free(nvl);
 255 
 256         return (-1);
 257 }
 258 
 259 /*
 260  * Pack a list of ri_dev_t's.
 261  */
 262 static int
 263 dev_list_pack(ri_dev_t *devlist, char **bufp, size_t *sizep, int encoding)
 264 {
 265         nvlist_t        *nvl = NULL;
 266         char            *buf = NULL;
 267         size_t          size = 0;
 268 
 269         assert(bufp != NULL && sizep != NULL);
 270 
 271         *sizep = 0;
 272         *bufp = NULL;
 273 


 287                             "(%s)\n", RI_DEV_T));
 288                         goto fail;
 289                 }
 290                 devlist = devlist->next;
 291         }
 292 
 293         s_free(buf);
 294         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 295                 dprintf((stderr, "nvlist_pack fail\n"));
 296                 goto fail;
 297         }
 298 
 299         nvlist_free(nvl);
 300         *bufp = buf;
 301         *sizep = size;
 302 
 303         return (0);
 304 
 305 fail:
 306         s_free(buf);
 307         if (nvl != NULL)
 308                 nvlist_free(nvl);
 309 
 310         return (-1);
 311 }
 312 
 313 /*
 314  * Pack a list of ri_client_t's.
 315  */
 316 static int
 317 client_list_pack(ri_client_t *client_list, char **bufp, size_t *sizep,
 318     int encoding)
 319 {
 320         nvlist_t        *nvl = NULL;
 321         char            *buf = NULL;
 322         size_t          size = 0;
 323 
 324         assert(bufp != NULL && sizep != NULL);
 325 
 326         *sizep = 0;
 327         *bufp = NULL;


 342                             "(%s)\n", RI_CLIENT_T));
 343                         goto fail;
 344                 }
 345                 client_list = client_list->next;
 346         }
 347 
 348         s_free(buf);
 349         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 350                 dprintf((stderr, "nvlist_pack fail\n"));
 351                 goto fail;
 352         }
 353 
 354         nvlist_free(nvl);
 355         *bufp = buf;
 356         *sizep = size;
 357 
 358         return (0);
 359 
 360 fail:
 361         s_free(buf);
 362         if (nvl != NULL)
 363                 nvlist_free(nvl);
 364 
 365         return (-1);
 366 }
 367 
 368 static int
 369 ap_pack(ri_ap_t *ap, char **bufp, size_t *sizep, int encoding)
 370 {
 371         nvlist_t        *nvl = NULL;
 372         char            *buf = NULL;
 373         size_t          size = 0;
 374 
 375         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 376                 dprintf((stderr, "nvlist_alloc fail\n"));
 377                 return (-1);
 378         }
 379 
 380         if (pack_add_byte_array(ap->conf_props, RI_AP_PROPS, nvl,
 381             encoding) != 0)
 382                 goto fail;


 407         if (nvlist_add_byte_array(nvl, RI_AP_IOS, (uchar_t *)buf,
 408             size) != 0) {
 409                 dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_IOS));
 410                 goto fail;
 411         }
 412 
 413         s_free(buf);
 414         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 415                 dprintf((stderr, "nvlist_pack fail\n"));
 416                 goto fail;
 417         }
 418 
 419         nvlist_free(nvl);
 420         *bufp = buf;
 421         *sizep = size;
 422 
 423         return (0);
 424 
 425 fail:
 426         s_free(buf);
 427         if (nvl != NULL)
 428                 nvlist_free(nvl);
 429 
 430         return (-1);
 431 }
 432 
 433 static int
 434 dev_pack(ri_dev_t *dev, char **bufp, size_t *sizep, int encoding)
 435 {
 436         nvlist_t        *nvl = NULL;
 437         char            *buf = NULL;
 438         size_t          size = 0;
 439 
 440         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 441                 dprintf((stderr, "nvlist_alloc fail\n"));
 442                 return (-1);
 443         }
 444 
 445         if (pack_add_byte_array(dev->conf_props, RI_DEV_PROPS, nvl,
 446             encoding) != 0)
 447                 goto fail;


 453             size) != 0) {
 454                 dprintf((stderr, "nvlist_add_byte_array (%s)n",
 455                     RI_DEV_CLIENTS));
 456                 goto fail;
 457         }
 458 
 459         s_free(buf);
 460         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 461                 dprintf((stderr, "nvlist_pack fail\n"));
 462                 goto fail;
 463         }
 464 
 465         nvlist_free(nvl);
 466         *bufp = buf;
 467         *sizep = size;
 468 
 469         return (0);
 470 
 471 fail:
 472         s_free(buf);
 473         if (nvl != NULL)
 474                 nvlist_free(nvl);
 475 
 476         return (-1);
 477 }
 478 
 479 static int
 480 client_pack(ri_client_t *client, char **bufp, size_t *sizep, int encoding)
 481 {
 482         nvlist_t        *nvl = NULL;
 483         char            *buf = NULL;
 484         size_t          size = 0;
 485 
 486         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 487                 dprintf((stderr, "nvlist_alloc fail\n"));
 488                 return (-1);
 489         }
 490 
 491         if (pack_add_byte_array(client->usg_props, RI_CLIENT_USAGE_PROPS,
 492             nvl, encoding) != 0) {
 493                 goto fail;


 498          * in the call to ri_init.
 499          */
 500         if (client->v_props != NULL && pack_add_byte_array(client->v_props,
 501             RI_CLIENT_VERB_PROPS, nvl, encoding) != 0) {
 502                 goto fail;
 503         }
 504 
 505         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 506                 dprintf((stderr, "nvlist_pack fail\n"));
 507                 goto fail;
 508         }
 509 
 510         nvlist_free(nvl);
 511         *bufp = buf;
 512         *sizep = size;
 513 
 514         return (0);
 515 
 516 fail:
 517         s_free(buf);
 518         if (nvl != NULL)
 519                 nvlist_free(nvl);
 520 
 521         return (-1);
 522 }
 523 
 524 /*
 525  * Pack nvlist_t and add as byte array to another nvlist_t.
 526  */
 527 static int
 528 pack_add_byte_array(nvlist_t *nvl_packme, char *name, nvlist_t *nvl,
 529     int encoding)
 530 {
 531         char    *buf = NULL;
 532         size_t  size = 0;
 533 
 534         if (nvlist_pack(nvl_packme, &buf, &size, encoding, 0) != 0) {
 535                 dprintf((stderr, "nvlist_pack fail (%s)\n", name));
 536                 s_free(buf);
 537                 return (-1);
 538         }


 600                 goto fail;
 601 
 602         buf = NULL;
 603         size = 0;
 604         if (nvlist_lookup_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t **)&buf,
 605             (uint_t *)&size) != 0) {
 606                 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
 607                     RI_HDL_MEM_CAPS));
 608                 goto fail;
 609         }
 610 
 611         if (client_list_unpack(buf, size, &ri_hdl->mem_cap_clients) != 0)
 612                 goto fail;
 613 
 614         *hdlp = ri_hdl;
 615 
 616         return (0);
 617 
 618 fail:
 619         free(ri_hdl);
 620         if (nvl != NULL)
 621                 nvlist_free(nvl);
 622 
 623         return (-1);
 624 }
 625 
 626 static int
 627 ap_list_unpack(char *buf, size_t size, ri_ap_t **aps)
 628 {
 629         nvpair_t        *nvp = NULL;
 630         nvlist_t        *nvl;
 631         ri_ap_t         *aplist = NULL;
 632         ri_ap_t         *prev = NULL;
 633         ri_ap_t         *tmp = NULL;
 634 
 635         if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
 636                 dprintf((stderr, "nvlist_unpack fail\n"));
 637                 return (-1);
 638         }
 639 
 640         while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {


 654                         goto fail;
 655                 }
 656 
 657                 if (ap_unpack(buf, size, tmp) != 0)
 658                         goto fail;
 659 
 660                 if (aplist == NULL) {
 661                         prev = aplist = tmp;
 662                 } else {
 663                         prev->next = tmp;
 664                         prev = tmp;
 665                 }
 666         }
 667 
 668         nvlist_free(nvl);
 669         *aps = aplist;
 670 
 671         return (0);
 672 
 673 fail:
 674         if (nvl != NULL)
 675                 nvlist_free(nvl);
 676         if (aplist != NULL) {
 677                 while ((tmp = aplist) != NULL) {
 678                         aplist = aplist->next;
 679                         ri_ap_free(tmp);
 680                 }
 681         }
 682 
 683         return (-1);
 684 }
 685 
 686 static int
 687 dev_list_unpack(char *buf, size_t size, ri_dev_t **devs)
 688 {
 689         nvpair_t        *nvp = NULL;
 690         nvlist_t        *nvl;
 691         ri_dev_t        *devlist = NULL;
 692         ri_dev_t        *prev = NULL;
 693         ri_dev_t        *tmp = NULL;
 694 


 712                         goto fail;
 713                 }
 714 
 715                 if (dev_unpack(buf, size, tmp) != 0)
 716                         goto fail;
 717 
 718                 if (devlist == NULL) {
 719                         prev = devlist = tmp;
 720                 } else {
 721                         prev->next = tmp;
 722                         prev = tmp;
 723                 }
 724         }
 725 
 726         nvlist_free(nvl);
 727         *devs = devlist;
 728 
 729         return (0);
 730 
 731 fail:
 732         if (nvl != NULL)
 733                 nvlist_free(nvl);
 734         if (devlist != NULL) {
 735                 while ((tmp = devlist) != NULL) {
 736                         devlist = devlist->next;
 737                         ri_dev_free(tmp);
 738                 }
 739         }
 740 
 741         return (-1);
 742 }
 743 
 744 static int
 745 client_list_unpack(char *buf, size_t size, ri_client_t **clients)
 746 {
 747         nvpair_t        *nvp = NULL;
 748         nvlist_t        *nvl;
 749         ri_client_t     *client_list = NULL;
 750         ri_client_t     *prev = NULL;
 751         ri_client_t     *tmp = NULL;
 752 


 772                         goto fail;
 773                 }
 774 
 775                 if (client_unpack(buf, size, tmp) != 0)
 776                         goto fail;
 777 
 778                 if (client_list == NULL) {
 779                         prev = client_list = tmp;
 780                 } else {
 781                         prev->next = tmp;
 782                         prev = tmp;
 783                 }
 784         }
 785 
 786         nvlist_free(nvl);
 787         *clients = client_list;
 788 
 789         return (0);
 790 
 791 fail:
 792         if (nvl != NULL)
 793                 nvlist_free(nvl);
 794         if (client_list != NULL) {
 795                 while ((tmp = client_list) != NULL) {
 796                         client_list = client_list->next;
 797                         ri_client_free(tmp);
 798                 }
 799         }
 800 
 801         return (-1);
 802 }
 803 
 804 static int
 805 client_unpack(char *buf, size_t size, ri_client_t *client)
 806 {
 807         nvlist_t        *nvl;
 808 
 809         if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
 810                 dprintf((stderr, "nvlist_unpack fail\n"));
 811                 return (-1);
 812         }




   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 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 


  26 /*
  27  * Routines for traversing and packing/unpacking the handle
  28  * returned from ri_init.
  29  */
  30 
  31 #include <stdlib.h>
  32 #include <strings.h>
  33 #include "rsrc_info.h"
  34 #include "rsrc_info_impl.h"
  35 
  36 static int ap_list_pack(ri_ap_t *, char **, size_t *, int);
  37 static int ap_list_unpack(char *, size_t, ri_ap_t **);
  38 static int ap_pack(ri_ap_t *, char **, size_t *, int);
  39 static int ap_unpack(char *, size_t, ri_ap_t *);
  40 static int dev_list_pack(ri_dev_t *, char **, size_t *, int);
  41 static int dev_list_unpack(char *, size_t, ri_dev_t **);
  42 static int dev_pack(ri_dev_t *, char **, size_t *, int);
  43 static int dev_unpack(char *, size_t, ri_dev_t *);
  44 static int client_list_pack(ri_client_t *, char **, size_t *, int);
  45 static int client_list_unpack(char *, size_t, ri_client_t **);


  63                 ri_ap_free(ap);
  64         }
  65         while ((client = hdl->cpu_cap_clients) != NULL) {
  66                 hdl->cpu_cap_clients = client->next;
  67                 ri_client_free(client);
  68         }
  69         while ((client = hdl->mem_cap_clients) != NULL) {
  70                 hdl->mem_cap_clients = client->next;
  71                 ri_client_free(client);
  72         }
  73         free(hdl);
  74 }
  75 
  76 static void
  77 ri_ap_free(ri_ap_t *ap)
  78 {
  79         ri_dev_t        *dev;
  80 
  81         assert(ap != NULL);
  82 

  83         nvlist_free(ap->conf_props);
  84 
  85         while ((dev = ap->cpus) != NULL) {
  86                 ap->cpus = dev->next;
  87                 ri_dev_free(dev);
  88         }
  89         while ((dev = ap->mems) != NULL) {
  90                 ap->mems = dev->next;
  91                 ri_dev_free(dev);
  92         }
  93         while ((dev = ap->ios) != NULL) {
  94                 ap->ios = dev->next;
  95                 ri_dev_free(dev);
  96         }
  97         free(ap);
  98 }
  99 
 100 void
 101 ri_dev_free(ri_dev_t *dev)
 102 {
 103         ri_client_t     *client;
 104 
 105         assert(dev != NULL);
 106 
 107         nvlist_free(dev->conf_props);
 108         while ((client = dev->rcm_clients) != NULL) {
 109                 dev->rcm_clients = client->next;
 110                 ri_client_free(client);
 111         }
 112         free(dev);
 113 }
 114 
 115 void
 116 ri_client_free(ri_client_t *client)
 117 {
 118         assert(client != NULL);
 119 

 120         nvlist_free(client->usg_props);

 121         nvlist_free(client->v_props);
 122         free(client);
 123 }
 124 
 125 /*
 126  * Pack everything contained in the handle up inside out.
 127  */
 128 int
 129 ri_pack(ri_hdl_t *hdl, caddr_t *bufp, size_t *sizep, int encoding)
 130 {
 131         nvlist_t        *nvl = NULL;
 132         char            *buf = NULL;
 133         size_t          size = 0;
 134 
 135         if (bufp == NULL || sizep == NULL)
 136                 return (RI_INVAL);
 137 
 138         *sizep = 0;
 139         *bufp = NULL;
 140 


 174             encoding) != 0 ||
 175             nvlist_add_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t *)buf,
 176             size) != 0) {
 177                 goto fail;
 178         }
 179 
 180         s_free(buf);
 181         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 182                 dprintf((stderr, "nvlist_pack fail\n"));
 183                 goto fail;
 184         }
 185 
 186         nvlist_free(nvl);
 187         *bufp = buf;
 188         *sizep = size;
 189 
 190         return (RI_SUCCESS);
 191 
 192 fail:
 193         s_free(buf);

 194         nvlist_free(nvl);
 195 
 196         return (RI_FAILURE);
 197 }
 198 
 199 /*
 200  * Pack a list of attachment point handles.
 201  */
 202 static int
 203 ap_list_pack(ri_ap_t *aplist, char **bufp, size_t *sizep, int encoding)
 204 {
 205         nvlist_t        *nvl = NULL;
 206         char            *buf = NULL;
 207         size_t          size;
 208 
 209         assert(bufp != NULL && sizep != NULL);
 210 
 211         *sizep = 0;
 212         *bufp = NULL;
 213 


 227                             "(%s)\n", RI_AP_T));
 228                         goto fail;
 229                 }
 230                 aplist = aplist->next;
 231         }
 232 
 233         s_free(buf);
 234         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 235                 dprintf((stderr, "nvlist_pack fail\n"));
 236                 goto fail;
 237         }
 238 
 239         nvlist_free(nvl);
 240         *bufp = buf;
 241         *sizep = size;
 242 
 243         return (0);
 244 
 245 fail:
 246         s_free(buf);

 247         nvlist_free(nvl);
 248 
 249         return (-1);
 250 }
 251 
 252 /*
 253  * Pack a list of ri_dev_t's.
 254  */
 255 static int
 256 dev_list_pack(ri_dev_t *devlist, char **bufp, size_t *sizep, int encoding)
 257 {
 258         nvlist_t        *nvl = NULL;
 259         char            *buf = NULL;
 260         size_t          size = 0;
 261 
 262         assert(bufp != NULL && sizep != NULL);
 263 
 264         *sizep = 0;
 265         *bufp = NULL;
 266 


 280                             "(%s)\n", RI_DEV_T));
 281                         goto fail;
 282                 }
 283                 devlist = devlist->next;
 284         }
 285 
 286         s_free(buf);
 287         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 288                 dprintf((stderr, "nvlist_pack fail\n"));
 289                 goto fail;
 290         }
 291 
 292         nvlist_free(nvl);
 293         *bufp = buf;
 294         *sizep = size;
 295 
 296         return (0);
 297 
 298 fail:
 299         s_free(buf);

 300         nvlist_free(nvl);
 301 
 302         return (-1);
 303 }
 304 
 305 /*
 306  * Pack a list of ri_client_t's.
 307  */
 308 static int
 309 client_list_pack(ri_client_t *client_list, char **bufp, size_t *sizep,
 310     int encoding)
 311 {
 312         nvlist_t        *nvl = NULL;
 313         char            *buf = NULL;
 314         size_t          size = 0;
 315 
 316         assert(bufp != NULL && sizep != NULL);
 317 
 318         *sizep = 0;
 319         *bufp = NULL;


 334                             "(%s)\n", RI_CLIENT_T));
 335                         goto fail;
 336                 }
 337                 client_list = client_list->next;
 338         }
 339 
 340         s_free(buf);
 341         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 342                 dprintf((stderr, "nvlist_pack fail\n"));
 343                 goto fail;
 344         }
 345 
 346         nvlist_free(nvl);
 347         *bufp = buf;
 348         *sizep = size;
 349 
 350         return (0);
 351 
 352 fail:
 353         s_free(buf);

 354         nvlist_free(nvl);
 355 
 356         return (-1);
 357 }
 358 
 359 static int
 360 ap_pack(ri_ap_t *ap, char **bufp, size_t *sizep, int encoding)
 361 {
 362         nvlist_t        *nvl = NULL;
 363         char            *buf = NULL;
 364         size_t          size = 0;
 365 
 366         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 367                 dprintf((stderr, "nvlist_alloc fail\n"));
 368                 return (-1);
 369         }
 370 
 371         if (pack_add_byte_array(ap->conf_props, RI_AP_PROPS, nvl,
 372             encoding) != 0)
 373                 goto fail;


 398         if (nvlist_add_byte_array(nvl, RI_AP_IOS, (uchar_t *)buf,
 399             size) != 0) {
 400                 dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_IOS));
 401                 goto fail;
 402         }
 403 
 404         s_free(buf);
 405         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 406                 dprintf((stderr, "nvlist_pack fail\n"));
 407                 goto fail;
 408         }
 409 
 410         nvlist_free(nvl);
 411         *bufp = buf;
 412         *sizep = size;
 413 
 414         return (0);
 415 
 416 fail:
 417         s_free(buf);

 418         nvlist_free(nvl);
 419 
 420         return (-1);
 421 }
 422 
 423 static int
 424 dev_pack(ri_dev_t *dev, char **bufp, size_t *sizep, int encoding)
 425 {
 426         nvlist_t        *nvl = NULL;
 427         char            *buf = NULL;
 428         size_t          size = 0;
 429 
 430         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 431                 dprintf((stderr, "nvlist_alloc fail\n"));
 432                 return (-1);
 433         }
 434 
 435         if (pack_add_byte_array(dev->conf_props, RI_DEV_PROPS, nvl,
 436             encoding) != 0)
 437                 goto fail;


 443             size) != 0) {
 444                 dprintf((stderr, "nvlist_add_byte_array (%s)n",
 445                     RI_DEV_CLIENTS));
 446                 goto fail;
 447         }
 448 
 449         s_free(buf);
 450         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 451                 dprintf((stderr, "nvlist_pack fail\n"));
 452                 goto fail;
 453         }
 454 
 455         nvlist_free(nvl);
 456         *bufp = buf;
 457         *sizep = size;
 458 
 459         return (0);
 460 
 461 fail:
 462         s_free(buf);

 463         nvlist_free(nvl);
 464 
 465         return (-1);
 466 }
 467 
 468 static int
 469 client_pack(ri_client_t *client, char **bufp, size_t *sizep, int encoding)
 470 {
 471         nvlist_t        *nvl = NULL;
 472         char            *buf = NULL;
 473         size_t          size = 0;
 474 
 475         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
 476                 dprintf((stderr, "nvlist_alloc fail\n"));
 477                 return (-1);
 478         }
 479 
 480         if (pack_add_byte_array(client->usg_props, RI_CLIENT_USAGE_PROPS,
 481             nvl, encoding) != 0) {
 482                 goto fail;


 487          * in the call to ri_init.
 488          */
 489         if (client->v_props != NULL && pack_add_byte_array(client->v_props,
 490             RI_CLIENT_VERB_PROPS, nvl, encoding) != 0) {
 491                 goto fail;
 492         }
 493 
 494         if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
 495                 dprintf((stderr, "nvlist_pack fail\n"));
 496                 goto fail;
 497         }
 498 
 499         nvlist_free(nvl);
 500         *bufp = buf;
 501         *sizep = size;
 502 
 503         return (0);
 504 
 505 fail:
 506         s_free(buf);

 507         nvlist_free(nvl);
 508 
 509         return (-1);
 510 }
 511 
 512 /*
 513  * Pack nvlist_t and add as byte array to another nvlist_t.
 514  */
 515 static int
 516 pack_add_byte_array(nvlist_t *nvl_packme, char *name, nvlist_t *nvl,
 517     int encoding)
 518 {
 519         char    *buf = NULL;
 520         size_t  size = 0;
 521 
 522         if (nvlist_pack(nvl_packme, &buf, &size, encoding, 0) != 0) {
 523                 dprintf((stderr, "nvlist_pack fail (%s)\n", name));
 524                 s_free(buf);
 525                 return (-1);
 526         }


 588                 goto fail;
 589 
 590         buf = NULL;
 591         size = 0;
 592         if (nvlist_lookup_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t **)&buf,
 593             (uint_t *)&size) != 0) {
 594                 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
 595                     RI_HDL_MEM_CAPS));
 596                 goto fail;
 597         }
 598 
 599         if (client_list_unpack(buf, size, &ri_hdl->mem_cap_clients) != 0)
 600                 goto fail;
 601 
 602         *hdlp = ri_hdl;
 603 
 604         return (0);
 605 
 606 fail:
 607         free(ri_hdl);

 608         nvlist_free(nvl);
 609 
 610         return (-1);
 611 }
 612 
 613 static int
 614 ap_list_unpack(char *buf, size_t size, ri_ap_t **aps)
 615 {
 616         nvpair_t        *nvp = NULL;
 617         nvlist_t        *nvl;
 618         ri_ap_t         *aplist = NULL;
 619         ri_ap_t         *prev = NULL;
 620         ri_ap_t         *tmp = NULL;
 621 
 622         if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
 623                 dprintf((stderr, "nvlist_unpack fail\n"));
 624                 return (-1);
 625         }
 626 
 627         while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {


 641                         goto fail;
 642                 }
 643 
 644                 if (ap_unpack(buf, size, tmp) != 0)
 645                         goto fail;
 646 
 647                 if (aplist == NULL) {
 648                         prev = aplist = tmp;
 649                 } else {
 650                         prev->next = tmp;
 651                         prev = tmp;
 652                 }
 653         }
 654 
 655         nvlist_free(nvl);
 656         *aps = aplist;
 657 
 658         return (0);
 659 
 660 fail:

 661         nvlist_free(nvl);
 662         if (aplist != NULL) {
 663                 while ((tmp = aplist) != NULL) {
 664                         aplist = aplist->next;
 665                         ri_ap_free(tmp);
 666                 }
 667         }
 668 
 669         return (-1);
 670 }
 671 
 672 static int
 673 dev_list_unpack(char *buf, size_t size, ri_dev_t **devs)
 674 {
 675         nvpair_t        *nvp = NULL;
 676         nvlist_t        *nvl;
 677         ri_dev_t        *devlist = NULL;
 678         ri_dev_t        *prev = NULL;
 679         ri_dev_t        *tmp = NULL;
 680 


 698                         goto fail;
 699                 }
 700 
 701                 if (dev_unpack(buf, size, tmp) != 0)
 702                         goto fail;
 703 
 704                 if (devlist == NULL) {
 705                         prev = devlist = tmp;
 706                 } else {
 707                         prev->next = tmp;
 708                         prev = tmp;
 709                 }
 710         }
 711 
 712         nvlist_free(nvl);
 713         *devs = devlist;
 714 
 715         return (0);
 716 
 717 fail:

 718         nvlist_free(nvl);
 719         if (devlist != NULL) {
 720                 while ((tmp = devlist) != NULL) {
 721                         devlist = devlist->next;
 722                         ri_dev_free(tmp);
 723                 }
 724         }
 725 
 726         return (-1);
 727 }
 728 
 729 static int
 730 client_list_unpack(char *buf, size_t size, ri_client_t **clients)
 731 {
 732         nvpair_t        *nvp = NULL;
 733         nvlist_t        *nvl;
 734         ri_client_t     *client_list = NULL;
 735         ri_client_t     *prev = NULL;
 736         ri_client_t     *tmp = NULL;
 737 


 757                         goto fail;
 758                 }
 759 
 760                 if (client_unpack(buf, size, tmp) != 0)
 761                         goto fail;
 762 
 763                 if (client_list == NULL) {
 764                         prev = client_list = tmp;
 765                 } else {
 766                         prev->next = tmp;
 767                         prev = tmp;
 768                 }
 769         }
 770 
 771         nvlist_free(nvl);
 772         *clients = client_list;
 773 
 774         return (0);
 775 
 776 fail:

 777         nvlist_free(nvl);
 778         if (client_list != NULL) {
 779                 while ((tmp = client_list) != NULL) {
 780                         client_list = client_list->next;
 781                         ri_client_free(tmp);
 782                 }
 783         }
 784 
 785         return (-1);
 786 }
 787 
 788 static int
 789 client_unpack(char *buf, size_t size, ri_client_t *client)
 790 {
 791         nvlist_t        *nvl;
 792 
 793         if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
 794                 dprintf((stderr, "nvlist_unpack fail\n"));
 795                 return (-1);
 796         }