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 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 **);
48 static int client_pack(ri_client_t *, char **, size_t *, int);
49 static int client_unpack(char *, size_t, ri_client_t *);
50 static int pack_add_byte_array(nvlist_t *, char *, nvlist_t *, int);
51 static int lookup_unpack_byte_array(nvlist_t *, char *, nvlist_t **);
52 static void ri_ap_free(ri_ap_t *);
53
54 void
55 ri_fini(ri_hdl_t *hdl)
56 {
57 ri_ap_t *ap;
58 ri_client_t *client;
59
60 if (hdl == NULL)
61 return;
62
63 while ((ap = hdl->aps) != NULL) {
64 hdl->aps = ap->next;
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
146 /*
147 * Check the handle. If it is NULL, there
148 * is nothing to pack, so we are done.
149 */
150 if (hdl == NULL) {
151 return (RI_SUCCESS);
152 }
153
154 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
155 dprintf((stderr, "nvlist_alloc fail\n", errno));
156 goto fail;
157 }
158
159 if (nvlist_add_int32(nvl, RI_HDL_FLAGS, hdl->flags) != 0) {
160 dprintf((stderr, "nvlist_add_int32 fail\n"));
161 goto fail;
162 }
163
164 if (ap_list_pack(hdl->aps, &buf, &size, encoding) != 0 ||
165 nvlist_add_byte_array(nvl, RI_HDL_APS, (uchar_t *)buf, size) != 0) {
166 goto fail;
167 }
168
169 s_free(buf);
170 if (client_list_pack(hdl->cpu_cap_clients, &buf, &size,
171 encoding) != 0 ||
172 nvlist_add_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t *)buf,
173 size) != 0) {
174 goto fail;
175 }
176
177 s_free(buf);
178 if (client_list_pack(hdl->mem_cap_clients, &buf, &size,
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
220 if (nvlist_alloc(&nvl, 0, 0) != 0) {
221 dprintf((stderr, "nvlist_alloc fail\n"));
222 return (-1);
223 }
224
225 while (aplist != NULL) {
226 s_free(buf);
227 if (ap_pack(aplist, &buf, &size, encoding) != 0)
228 goto fail;
229
230 if (nvlist_add_byte_array(nvl, RI_AP_T, (uchar_t *)buf,
231 size) != 0) {
232 dprintf((stderr, "nvlist_add_byte_array fail "
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
274 if (nvlist_alloc(&nvl, 0, 0) != 0) {
275 dprintf((stderr, "nvlist_alloc fail\n"));
276 return (-1);
277 }
278
279 while (devlist != NULL) {
280 s_free(buf);
281 if (dev_pack(devlist, &buf, &size, encoding) != 0)
282 goto fail;
283
284 if (nvlist_add_byte_array(nvl, RI_DEV_T, (uchar_t *)buf,
285 size) != 0) {
286 dprintf((stderr, "nvlist_add_byte_array fail "
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;
328
329 if (nvlist_alloc(&nvl, 0, 0) != 0) {
330 dprintf((stderr, "nvlist_alloc fail\n"));
331 return (-1);
332 }
333
334 while (client_list != NULL) {
335 s_free(buf);
336 if (client_pack(client_list, &buf, &size, encoding) != 0)
337 goto fail;
338
339 if (nvlist_add_byte_array(nvl, RI_CLIENT_T, (uchar_t *)buf,
340 size) != 0) {
341 dprintf((stderr, "nvlist_add_byte_array fail "
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;
383
384 if (dev_list_pack(ap->cpus, &buf, &size, encoding) != 0)
385 goto fail;
386
387 if (nvlist_add_byte_array(nvl, RI_AP_CPUS, (uchar_t *)buf,
388 size) != 0) {
389 dprintf((stderr, "nvlist_add_byte_array (%s)\n", RI_AP_CPUS));
390 goto fail;
391 }
392
393 s_free(buf);
394 if (dev_list_pack(ap->mems, &buf, &size, encoding) != 0)
395 goto fail;
396
397 if (nvlist_add_byte_array(nvl, RI_AP_MEMS, (uchar_t *)buf,
398 size) != 0) {
399 dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_MEMS));
400 goto fail;
401 }
402
403 s_free(buf);
404 if (dev_list_pack(ap->ios, &buf, &size, encoding) != 0)
405 goto fail;
406
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;
448
449 if (client_list_pack(dev->rcm_clients, &buf, &size, encoding) != 0)
450 goto fail;
451
452 if (nvlist_add_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t *)buf,
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;
494 }
495
496 /*
497 * This will only be present if RI_VERBOSE was specified
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 }
539
540 if (nvlist_add_byte_array(nvl, name, (uchar_t *)buf, size) != 0) {
541 dprintf((stderr, "nvlist_add_byte_array fail (%s)\n", name));
542 return (-1);
543 }
544
545 s_free(buf);
546 return (0);
547 }
548
549 /*
550 * Unpack buf into ri_hdl_t.
551 */
552 int
553 ri_unpack(caddr_t buf, size_t size, ri_hdl_t **hdlp)
554 {
555 ri_hdl_t *ri_hdl = NULL;
556 nvlist_t *nvl = NULL;
557
558 if (hdlp == NULL)
559 return (RI_INVAL);
560
561 *hdlp = NULL;
562 if ((ri_hdl = calloc(1, sizeof (*ri_hdl))) == NULL) {
563 dprintf((stderr, "calloc: %s\n", strerror(errno)));
564 return (RI_FAILURE);
565 }
566
567 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
568 dprintf((stderr, "nvlist_unpack fail\n"));
569 goto fail;
570 }
571
572 if (nvlist_lookup_int32(nvl, RI_HDL_FLAGS, &ri_hdl->flags) != 0) {
573 dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
574 RI_HDL_FLAGS));
575 goto fail;
576 }
577
578 buf = NULL;
579 size = 0;
580 if (nvlist_lookup_byte_array(nvl, RI_HDL_APS, (uchar_t **)&buf,
581 (uint_t *)&size) != 0) {
582 dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
583 RI_HDL_APS));
584 goto fail;
585 }
586
587 if (ap_list_unpack(buf, size, &ri_hdl->aps) != 0)
588 goto fail;
589
590 buf = NULL;
591 size = 0;
592 if (nvlist_lookup_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t **)&buf,
593 (uint_t *)&size) != 0) {
594 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
595 RI_HDL_CPU_CAPS));
596 goto fail;
597 }
598
599 if (client_list_unpack(buf, size, &ri_hdl->cpu_cap_clients) != 0)
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) {
641 assert(strcmp(nvpair_name(nvp), RI_AP_T) == 0 &&
642 nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
643
644 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
645 dprintf((stderr, "calloc: %s\n", strerror(errno)));
646 goto fail;
647 }
648
649 buf = NULL;
650 size = 0;
651 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
652 (uint_t *)&size) != 0) {
653 dprintf((stderr, "nvpair_value_byte_array fail\n"));
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
695 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
696 dprintf((stderr, "nvlist_unpack fail\n"));
697 return (-1);
698 }
699
700 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
701 assert(strcmp(nvpair_name(nvp), RI_DEV_T) == 0 &&
702 nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
703
704 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
705 dprintf((stderr, "calloc: %s\n", strerror(errno)));
706 goto fail;
707 }
708
709 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
710 (uint_t *)&size) != 0) {
711 dprintf((stderr, "nvpair_value_byte_array fail\n"));
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
753 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
754 dprintf((stderr, "nvlist_unpack fail\n"));
755 return (-1);
756 }
757
758 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
759 assert(strcmp(nvpair_name(nvp), RI_CLIENT_T) == 0);
760 assert(nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
761
762 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
763 dprintf((stderr, "calloc: %s\n", strerror(errno)));
764 goto fail;
765 }
766
767 buf = NULL;
768 size = 0;
769 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
770 (uint_t *)&size) != 0) {
771 dprintf((stderr, "nvpair_value_byte_array fail\n"));
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 }
813
814 if (lookup_unpack_byte_array(nvl, RI_CLIENT_USAGE_PROPS,
815 &client->usg_props) != 0) {
816 nvlist_free(nvl);
817 return (-1);
818 }
819
820 #ifdef DEBUG
821 nvlist_print(stderr, client->usg_props);
822 #endif /* DEBUG */
823
824 /*
825 * Verbose properties for RCM clients only present if
826 * RI_VERBOSE was specified for ri_init.
827 */
828 buf = NULL;
829 size = 0;
830 if (nvlist_lookup_byte_array(nvl, RI_CLIENT_VERB_PROPS,
831 (uchar_t **)&buf, (uint_t *)&size) == 0) {
832 if (nvlist_unpack(buf, size, &client->v_props, 0) != 0) {
833 dprintf((stderr, "nvlist_unpack fail (%s)\n",
834 RI_CLIENT_VERB_PROPS));
835 nvlist_free(nvl);
836 return (-1);
837 }
838 }
839
840 nvlist_free(nvl);
841
842 return (0);
843 }
844
845 static int
846 dev_unpack(char *buf, size_t size, ri_dev_t *dev)
847 {
848 nvlist_t *nvl;
849
850 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
851 dprintf((stderr, "nvlist_unpack fail\n"));
852 return (-1);
853 }
854
855 if (lookup_unpack_byte_array(nvl, RI_DEV_PROPS,
856 &dev->conf_props) != 0) {
857 nvlist_free(nvl);
858 return (-1);
859 }
860
861 #ifdef DEBUG
862 nvlist_print(stderr, dev->conf_props);
863 #endif /* DEBUG */
864
865 if (nvlist_lookup_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t **)&buf,
866 (uint_t *)&size) != 0) {
867 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
868 RI_DEV_CLIENTS));
869 nvlist_free(nvl);
870 return (-1);
871 }
872
873 if (client_list_unpack(buf, size, &dev->rcm_clients) != 0) {
874 nvlist_free(nvl);
875 return (-1);
876 }
877
878 nvlist_free(nvl);
879
880 return (0);
881 }
882
883 static int
884 ap_unpack(char *buf, size_t size, ri_ap_t *ap)
885 {
886 nvlist_t *nvl;
887
888 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
889 dprintf((stderr, "nvlist_unpack fail\n"));
890 return (-1);
891 }
892
893 if (lookup_unpack_byte_array(nvl, RI_AP_PROPS, &ap->conf_props) != 0) {
894 nvlist_free(nvl);
895 return (-1);
896 }
897
898 #ifdef DEBUG
899 nvlist_print(stderr, ap->conf_props);
900 #endif /* DEBUG */
901
902 if (nvlist_lookup_byte_array(nvl, RI_AP_CPUS, (uchar_t **)&buf,
903 (uint_t *)&size) != 0) {
904 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
905 RI_AP_CPUS));
906 nvlist_free(nvl);
907 return (-1);
908 }
909
910 if (dev_list_unpack(buf, size, &ap->cpus) != 0) {
911 nvlist_free(nvl);
912 return (-1);
913 }
914
915 if (nvlist_lookup_byte_array(nvl, RI_AP_MEMS, (uchar_t **)&buf,
916 (uint_t *)&size) != 0) {
917 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
918 RI_AP_MEMS));
919 nvlist_free(nvl);
920 return (-1);
921 }
922
923 if (dev_list_unpack(buf, size, &ap->mems) != 0) {
924 nvlist_free(nvl);
925 return (-1);
926 }
927
928 if (nvlist_lookup_byte_array(nvl, RI_AP_IOS, (uchar_t **)&buf,
929 (uint_t *)&size) != 0) {
930 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
931 RI_AP_IOS));
932 nvlist_free(nvl);
933 return (-1);
934 }
935
936 if (dev_list_unpack(buf, size, &ap->ios) != 0) {
937 nvlist_free(nvl);
938 return (-1);
939 }
940
941 nvlist_free(nvl);
942
943 return (0);
944 }
945
946 /*
947 * Lookup byte array in old nvlist_t and unpack into new nvlist_t.
948 */
949 static int
950 lookup_unpack_byte_array(nvlist_t *old_nvl, char *name, nvlist_t **new_nvl)
951 {
952 char *buf = NULL;
953 size_t size = 0;
954
955 if (nvlist_lookup_byte_array(old_nvl, name, (uchar_t **)&buf,
956 (uint_t *)&size) != 0) {
957 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
958 name));
959 return (-1);
960 }
961
962 if (nvlist_unpack(buf, size, new_nvl, 0) != 0) {
963 dprintf((stderr, "nvlist_unpack fail (%s)\n", name));
964 return (-1);
965 }
966
967 return (0);
968 }
969
970 ri_ap_t *
971 ri_ap_next(ri_hdl_t *hdl, ri_ap_t *ap)
972 {
973 if (hdl == NULL) {
974 errno = EINVAL;
975 return (NULL);
976 }
977 return ((ap == NULL) ? hdl->aps : ap->next);
978 }
979
980 nvlist_t *
981 ri_ap_conf_props(ri_ap_t *ap)
982 {
983 if (ap == NULL) {
984 errno = EINVAL;
985 return (NULL);
986 }
987 return (ap->conf_props);
988 }
989
990 ri_dev_t *
991 ri_cpu_next(ri_ap_t *ap, ri_dev_t *cpu)
992 {
993 if (ap == NULL) {
994 errno = EINVAL;
995 return (NULL);
996 }
997 return ((cpu == NULL) ? ap->cpus : cpu->next);
998 }
999
1000 ri_dev_t *
1001 ri_mem_next(ri_ap_t *ap, ri_dev_t *mem)
1002 {
1003 if (ap == NULL) {
1004 errno = EINVAL;
1005 return (NULL);
1006 }
1007 return ((mem == NULL) ? ap->mems : mem->next);
1008 }
1009
1010 ri_dev_t *
1011 ri_io_next(ri_ap_t *ap, ri_dev_t *io)
1012 {
1013 if (ap == NULL) {
1014 errno = EINVAL;
1015 return (NULL);
1016 }
1017 return ((io == NULL) ? ap->ios : io->next);
1018 }
1019
1020 ri_client_t *
1021 ri_client_next(ri_dev_t *dev, ri_client_t *rcm_client)
1022 {
1023 if (dev == NULL) {
1024 errno = EINVAL;
1025 return (NULL);
1026 }
1027 return ((rcm_client == NULL) ? dev->rcm_clients : rcm_client->next);
1028 }
1029
1030 nvlist_t *
1031 ri_dev_conf_props(ri_dev_t *dev)
1032 {
1033 if (dev == NULL) {
1034 errno = EINVAL;
1035 return (NULL);
1036 }
1037 return (dev->conf_props);
1038 }
1039
1040 nvlist_t *
1041 ri_client_usage_props(ri_client_t *rcm_client)
1042 {
1043 if (rcm_client == NULL) {
1044 errno = EINVAL;
1045 return (NULL);
1046 }
1047 return (rcm_client->usg_props);
1048 }
1049
1050 nvlist_t *
1051 ri_client_verbose_props(ri_client_t *rcm_client)
1052 {
1053 if (rcm_client == NULL) {
1054 errno = EINVAL;
1055 return (NULL);
1056 }
1057 return (rcm_client->v_props);
1058 }
1059
1060 ri_client_t *
1061 ri_cpu_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
1062 {
1063 if (hdl == NULL) {
1064 errno = EINVAL;
1065 return (NULL);
1066 }
1067 return ((rcm_client == NULL) ? hdl->cpu_cap_clients : rcm_client->next);
1068 }
1069
1070 ri_client_t *
1071 ri_mem_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
1072 {
1073 if (hdl == NULL) {
1074 errno = EINVAL;
1075 return (NULL);
1076 }
1077 return ((rcm_client == NULL) ? hdl->mem_cap_clients : rcm_client->next);
1078 }