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 }
|