Print this page
patch tsoome-feedback
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/cmd/dcs/sparc/sun4u/rsrc_info.c
+++ new/usr/src/cmd/dcs/sparc/sun4u/rsrc_info.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 -#pragma ident "%Z%%M% %I% %E% SMI"
27 -
28 26 /*
29 27 * Routines for traversing and packing/unpacking the handle
30 28 * returned from ri_init.
31 29 */
32 30
33 31 #include <stdlib.h>
34 32 #include <strings.h>
35 33 #include "rsrc_info.h"
36 34 #include "rsrc_info_impl.h"
37 35
38 36 static int ap_list_pack(ri_ap_t *, char **, size_t *, int);
39 37 static int ap_list_unpack(char *, size_t, ri_ap_t **);
40 38 static int ap_pack(ri_ap_t *, char **, size_t *, int);
41 39 static int ap_unpack(char *, size_t, ri_ap_t *);
42 40 static int dev_list_pack(ri_dev_t *, char **, size_t *, int);
43 41 static int dev_list_unpack(char *, size_t, ri_dev_t **);
44 42 static int dev_pack(ri_dev_t *, char **, size_t *, int);
45 43 static int dev_unpack(char *, size_t, ri_dev_t *);
46 44 static int client_list_pack(ri_client_t *, char **, size_t *, int);
47 45 static int client_list_unpack(char *, size_t, ri_client_t **);
48 46 static int client_pack(ri_client_t *, char **, size_t *, int);
49 47 static int client_unpack(char *, size_t, ri_client_t *);
50 48 static int pack_add_byte_array(nvlist_t *, char *, nvlist_t *, int);
51 49 static int lookup_unpack_byte_array(nvlist_t *, char *, nvlist_t **);
52 50 static void ri_ap_free(ri_ap_t *);
53 51
54 52 void
55 53 ri_fini(ri_hdl_t *hdl)
56 54 {
57 55 ri_ap_t *ap;
58 56 ri_client_t *client;
59 57
60 58 if (hdl == NULL)
61 59 return;
62 60
63 61 while ((ap = hdl->aps) != NULL) {
64 62 hdl->aps = ap->next;
65 63 ri_ap_free(ap);
66 64 }
67 65 while ((client = hdl->cpu_cap_clients) != NULL) {
68 66 hdl->cpu_cap_clients = client->next;
69 67 ri_client_free(client);
70 68 }
71 69 while ((client = hdl->mem_cap_clients) != NULL) {
72 70 hdl->mem_cap_clients = client->next;
73 71 ri_client_free(client);
74 72 }
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
75 73 free(hdl);
76 74 }
77 75
78 76 static void
79 77 ri_ap_free(ri_ap_t *ap)
80 78 {
81 79 ri_dev_t *dev;
82 80
83 81 assert(ap != NULL);
84 82
85 - if (ap->conf_props != NULL)
86 - nvlist_free(ap->conf_props);
83 + nvlist_free(ap->conf_props);
87 84
88 85 while ((dev = ap->cpus) != NULL) {
89 86 ap->cpus = dev->next;
90 87 ri_dev_free(dev);
91 88 }
92 89 while ((dev = ap->mems) != NULL) {
93 90 ap->mems = dev->next;
94 91 ri_dev_free(dev);
95 92 }
96 93 while ((dev = ap->ios) != NULL) {
97 94 ap->ios = dev->next;
98 95 ri_dev_free(dev);
99 96 }
100 97 free(ap);
101 98 }
102 99
103 100 void
104 101 ri_dev_free(ri_dev_t *dev)
105 102 {
106 103 ri_client_t *client;
107 104
108 105 assert(dev != NULL);
109 106
110 107 nvlist_free(dev->conf_props);
111 108 while ((client = dev->rcm_clients) != NULL) {
112 109 dev->rcm_clients = client->next;
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
113 110 ri_client_free(client);
114 111 }
115 112 free(dev);
116 113 }
117 114
118 115 void
119 116 ri_client_free(ri_client_t *client)
120 117 {
121 118 assert(client != NULL);
122 119
123 - if (client->usg_props != NULL)
124 - nvlist_free(client->usg_props);
125 - if (client->v_props != NULL)
126 - nvlist_free(client->v_props);
120 + nvlist_free(client->usg_props);
121 + nvlist_free(client->v_props);
127 122 free(client);
128 123 }
129 124
130 125 /*
131 126 * Pack everything contained in the handle up inside out.
132 127 */
133 128 int
134 129 ri_pack(ri_hdl_t *hdl, caddr_t *bufp, size_t *sizep, int encoding)
135 130 {
136 131 nvlist_t *nvl = NULL;
137 132 char *buf = NULL;
138 133 size_t size = 0;
139 134
140 135 if (bufp == NULL || sizep == NULL)
141 136 return (RI_INVAL);
142 137
143 138 *sizep = 0;
144 139 *bufp = NULL;
145 140
146 141 /*
147 142 * Check the handle. If it is NULL, there
148 143 * is nothing to pack, so we are done.
149 144 */
150 145 if (hdl == NULL) {
151 146 return (RI_SUCCESS);
152 147 }
153 148
154 149 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
155 150 dprintf((stderr, "nvlist_alloc fail\n", errno));
156 151 goto fail;
157 152 }
158 153
159 154 if (nvlist_add_int32(nvl, RI_HDL_FLAGS, hdl->flags) != 0) {
160 155 dprintf((stderr, "nvlist_add_int32 fail\n"));
161 156 goto fail;
162 157 }
163 158
164 159 if (ap_list_pack(hdl->aps, &buf, &size, encoding) != 0 ||
165 160 nvlist_add_byte_array(nvl, RI_HDL_APS, (uchar_t *)buf, size) != 0) {
166 161 goto fail;
167 162 }
168 163
169 164 s_free(buf);
170 165 if (client_list_pack(hdl->cpu_cap_clients, &buf, &size,
171 166 encoding) != 0 ||
172 167 nvlist_add_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t *)buf,
173 168 size) != 0) {
174 169 goto fail;
175 170 }
176 171
177 172 s_free(buf);
178 173 if (client_list_pack(hdl->mem_cap_clients, &buf, &size,
179 174 encoding) != 0 ||
180 175 nvlist_add_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t *)buf,
181 176 size) != 0) {
182 177 goto fail;
183 178 }
184 179
185 180 s_free(buf);
186 181 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
187 182 dprintf((stderr, "nvlist_pack fail\n"));
188 183 goto fail;
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
189 184 }
190 185
191 186 nvlist_free(nvl);
192 187 *bufp = buf;
193 188 *sizep = size;
194 189
195 190 return (RI_SUCCESS);
196 191
197 192 fail:
198 193 s_free(buf);
199 - if (nvl != NULL)
200 - nvlist_free(nvl);
194 + nvlist_free(nvl);
201 195
202 196 return (RI_FAILURE);
203 197 }
204 198
205 199 /*
206 200 * Pack a list of attachment point handles.
207 201 */
208 202 static int
209 203 ap_list_pack(ri_ap_t *aplist, char **bufp, size_t *sizep, int encoding)
210 204 {
211 205 nvlist_t *nvl = NULL;
212 206 char *buf = NULL;
213 207 size_t size;
214 208
215 209 assert(bufp != NULL && sizep != NULL);
216 210
217 211 *sizep = 0;
218 212 *bufp = NULL;
219 213
220 214 if (nvlist_alloc(&nvl, 0, 0) != 0) {
221 215 dprintf((stderr, "nvlist_alloc fail\n"));
222 216 return (-1);
223 217 }
224 218
225 219 while (aplist != NULL) {
226 220 s_free(buf);
227 221 if (ap_pack(aplist, &buf, &size, encoding) != 0)
228 222 goto fail;
229 223
230 224 if (nvlist_add_byte_array(nvl, RI_AP_T, (uchar_t *)buf,
231 225 size) != 0) {
232 226 dprintf((stderr, "nvlist_add_byte_array fail "
233 227 "(%s)\n", RI_AP_T));
234 228 goto fail;
235 229 }
236 230 aplist = aplist->next;
237 231 }
238 232
239 233 s_free(buf);
240 234 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
241 235 dprintf((stderr, "nvlist_pack fail\n"));
242 236 goto fail;
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
243 237 }
244 238
245 239 nvlist_free(nvl);
246 240 *bufp = buf;
247 241 *sizep = size;
248 242
249 243 return (0);
250 244
251 245 fail:
252 246 s_free(buf);
253 - if (nvl != NULL)
254 - nvlist_free(nvl);
247 + nvlist_free(nvl);
255 248
256 249 return (-1);
257 250 }
258 251
259 252 /*
260 253 * Pack a list of ri_dev_t's.
261 254 */
262 255 static int
263 256 dev_list_pack(ri_dev_t *devlist, char **bufp, size_t *sizep, int encoding)
264 257 {
265 258 nvlist_t *nvl = NULL;
266 259 char *buf = NULL;
267 260 size_t size = 0;
268 261
269 262 assert(bufp != NULL && sizep != NULL);
270 263
271 264 *sizep = 0;
272 265 *bufp = NULL;
273 266
274 267 if (nvlist_alloc(&nvl, 0, 0) != 0) {
275 268 dprintf((stderr, "nvlist_alloc fail\n"));
276 269 return (-1);
277 270 }
278 271
279 272 while (devlist != NULL) {
280 273 s_free(buf);
281 274 if (dev_pack(devlist, &buf, &size, encoding) != 0)
282 275 goto fail;
283 276
284 277 if (nvlist_add_byte_array(nvl, RI_DEV_T, (uchar_t *)buf,
285 278 size) != 0) {
286 279 dprintf((stderr, "nvlist_add_byte_array fail "
287 280 "(%s)\n", RI_DEV_T));
288 281 goto fail;
289 282 }
290 283 devlist = devlist->next;
291 284 }
292 285
293 286 s_free(buf);
294 287 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
295 288 dprintf((stderr, "nvlist_pack fail\n"));
296 289 goto fail;
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
297 290 }
298 291
299 292 nvlist_free(nvl);
300 293 *bufp = buf;
301 294 *sizep = size;
302 295
303 296 return (0);
304 297
305 298 fail:
306 299 s_free(buf);
307 - if (nvl != NULL)
308 - nvlist_free(nvl);
300 + nvlist_free(nvl);
309 301
310 302 return (-1);
311 303 }
312 304
313 305 /*
314 306 * Pack a list of ri_client_t's.
315 307 */
316 308 static int
317 309 client_list_pack(ri_client_t *client_list, char **bufp, size_t *sizep,
318 310 int encoding)
319 311 {
320 312 nvlist_t *nvl = NULL;
321 313 char *buf = NULL;
322 314 size_t size = 0;
323 315
324 316 assert(bufp != NULL && sizep != NULL);
325 317
326 318 *sizep = 0;
327 319 *bufp = NULL;
328 320
329 321 if (nvlist_alloc(&nvl, 0, 0) != 0) {
330 322 dprintf((stderr, "nvlist_alloc fail\n"));
331 323 return (-1);
332 324 }
333 325
334 326 while (client_list != NULL) {
335 327 s_free(buf);
336 328 if (client_pack(client_list, &buf, &size, encoding) != 0)
337 329 goto fail;
338 330
339 331 if (nvlist_add_byte_array(nvl, RI_CLIENT_T, (uchar_t *)buf,
340 332 size) != 0) {
341 333 dprintf((stderr, "nvlist_add_byte_array fail "
342 334 "(%s)\n", RI_CLIENT_T));
343 335 goto fail;
344 336 }
345 337 client_list = client_list->next;
346 338 }
347 339
348 340 s_free(buf);
349 341 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
350 342 dprintf((stderr, "nvlist_pack fail\n"));
351 343 goto fail;
↓ open down ↓ |
33 lines elided |
↑ open up ↑ |
352 344 }
353 345
354 346 nvlist_free(nvl);
355 347 *bufp = buf;
356 348 *sizep = size;
357 349
358 350 return (0);
359 351
360 352 fail:
361 353 s_free(buf);
362 - if (nvl != NULL)
363 - nvlist_free(nvl);
354 + nvlist_free(nvl);
364 355
365 356 return (-1);
366 357 }
367 358
368 359 static int
369 360 ap_pack(ri_ap_t *ap, char **bufp, size_t *sizep, int encoding)
370 361 {
371 362 nvlist_t *nvl = NULL;
372 363 char *buf = NULL;
373 364 size_t size = 0;
374 365
375 366 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
376 367 dprintf((stderr, "nvlist_alloc fail\n"));
377 368 return (-1);
378 369 }
379 370
380 371 if (pack_add_byte_array(ap->conf_props, RI_AP_PROPS, nvl,
381 372 encoding) != 0)
382 373 goto fail;
383 374
384 375 if (dev_list_pack(ap->cpus, &buf, &size, encoding) != 0)
385 376 goto fail;
386 377
387 378 if (nvlist_add_byte_array(nvl, RI_AP_CPUS, (uchar_t *)buf,
388 379 size) != 0) {
389 380 dprintf((stderr, "nvlist_add_byte_array (%s)\n", RI_AP_CPUS));
390 381 goto fail;
391 382 }
392 383
393 384 s_free(buf);
394 385 if (dev_list_pack(ap->mems, &buf, &size, encoding) != 0)
395 386 goto fail;
396 387
397 388 if (nvlist_add_byte_array(nvl, RI_AP_MEMS, (uchar_t *)buf,
398 389 size) != 0) {
399 390 dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_MEMS));
400 391 goto fail;
401 392 }
402 393
403 394 s_free(buf);
404 395 if (dev_list_pack(ap->ios, &buf, &size, encoding) != 0)
405 396 goto fail;
406 397
407 398 if (nvlist_add_byte_array(nvl, RI_AP_IOS, (uchar_t *)buf,
408 399 size) != 0) {
409 400 dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_IOS));
410 401 goto fail;
411 402 }
412 403
413 404 s_free(buf);
414 405 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
415 406 dprintf((stderr, "nvlist_pack fail\n"));
416 407 goto fail;
↓ open down ↓ |
43 lines elided |
↑ open up ↑ |
417 408 }
418 409
419 410 nvlist_free(nvl);
420 411 *bufp = buf;
421 412 *sizep = size;
422 413
423 414 return (0);
424 415
425 416 fail:
426 417 s_free(buf);
427 - if (nvl != NULL)
428 - nvlist_free(nvl);
418 + nvlist_free(nvl);
429 419
430 420 return (-1);
431 421 }
432 422
433 423 static int
434 424 dev_pack(ri_dev_t *dev, char **bufp, size_t *sizep, int encoding)
435 425 {
436 426 nvlist_t *nvl = NULL;
437 427 char *buf = NULL;
438 428 size_t size = 0;
439 429
440 430 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
441 431 dprintf((stderr, "nvlist_alloc fail\n"));
442 432 return (-1);
443 433 }
444 434
445 435 if (pack_add_byte_array(dev->conf_props, RI_DEV_PROPS, nvl,
446 436 encoding) != 0)
447 437 goto fail;
448 438
449 439 if (client_list_pack(dev->rcm_clients, &buf, &size, encoding) != 0)
450 440 goto fail;
451 441
452 442 if (nvlist_add_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t *)buf,
453 443 size) != 0) {
454 444 dprintf((stderr, "nvlist_add_byte_array (%s)n",
455 445 RI_DEV_CLIENTS));
456 446 goto fail;
457 447 }
458 448
459 449 s_free(buf);
460 450 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
461 451 dprintf((stderr, "nvlist_pack fail\n"));
462 452 goto fail;
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
463 453 }
464 454
465 455 nvlist_free(nvl);
466 456 *bufp = buf;
467 457 *sizep = size;
468 458
469 459 return (0);
470 460
471 461 fail:
472 462 s_free(buf);
473 - if (nvl != NULL)
474 - nvlist_free(nvl);
463 + nvlist_free(nvl);
475 464
476 465 return (-1);
477 466 }
478 467
479 468 static int
480 469 client_pack(ri_client_t *client, char **bufp, size_t *sizep, int encoding)
481 470 {
482 471 nvlist_t *nvl = NULL;
483 472 char *buf = NULL;
484 473 size_t size = 0;
485 474
486 475 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
487 476 dprintf((stderr, "nvlist_alloc fail\n"));
488 477 return (-1);
489 478 }
490 479
491 480 if (pack_add_byte_array(client->usg_props, RI_CLIENT_USAGE_PROPS,
492 481 nvl, encoding) != 0) {
493 482 goto fail;
494 483 }
495 484
496 485 /*
497 486 * This will only be present if RI_VERBOSE was specified
498 487 * in the call to ri_init.
499 488 */
500 489 if (client->v_props != NULL && pack_add_byte_array(client->v_props,
501 490 RI_CLIENT_VERB_PROPS, nvl, encoding) != 0) {
502 491 goto fail;
503 492 }
504 493
505 494 if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
506 495 dprintf((stderr, "nvlist_pack fail\n"));
507 496 goto fail;
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
508 497 }
509 498
510 499 nvlist_free(nvl);
511 500 *bufp = buf;
512 501 *sizep = size;
513 502
514 503 return (0);
515 504
516 505 fail:
517 506 s_free(buf);
518 - if (nvl != NULL)
519 - nvlist_free(nvl);
507 + nvlist_free(nvl);
520 508
521 509 return (-1);
522 510 }
523 511
524 512 /*
525 513 * Pack nvlist_t and add as byte array to another nvlist_t.
526 514 */
527 515 static int
528 516 pack_add_byte_array(nvlist_t *nvl_packme, char *name, nvlist_t *nvl,
529 517 int encoding)
530 518 {
531 519 char *buf = NULL;
532 520 size_t size = 0;
533 521
534 522 if (nvlist_pack(nvl_packme, &buf, &size, encoding, 0) != 0) {
535 523 dprintf((stderr, "nvlist_pack fail (%s)\n", name));
536 524 s_free(buf);
537 525 return (-1);
538 526 }
539 527
540 528 if (nvlist_add_byte_array(nvl, name, (uchar_t *)buf, size) != 0) {
541 529 dprintf((stderr, "nvlist_add_byte_array fail (%s)\n", name));
542 530 return (-1);
543 531 }
544 532
545 533 s_free(buf);
546 534 return (0);
547 535 }
548 536
549 537 /*
550 538 * Unpack buf into ri_hdl_t.
551 539 */
552 540 int
553 541 ri_unpack(caddr_t buf, size_t size, ri_hdl_t **hdlp)
554 542 {
555 543 ri_hdl_t *ri_hdl = NULL;
556 544 nvlist_t *nvl = NULL;
557 545
558 546 if (hdlp == NULL)
559 547 return (RI_INVAL);
560 548
561 549 *hdlp = NULL;
562 550 if ((ri_hdl = calloc(1, sizeof (*ri_hdl))) == NULL) {
563 551 dprintf((stderr, "calloc: %s\n", strerror(errno)));
564 552 return (RI_FAILURE);
565 553 }
566 554
567 555 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
568 556 dprintf((stderr, "nvlist_unpack fail\n"));
569 557 goto fail;
570 558 }
571 559
572 560 if (nvlist_lookup_int32(nvl, RI_HDL_FLAGS, &ri_hdl->flags) != 0) {
573 561 dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
574 562 RI_HDL_FLAGS));
575 563 goto fail;
576 564 }
577 565
578 566 buf = NULL;
579 567 size = 0;
580 568 if (nvlist_lookup_byte_array(nvl, RI_HDL_APS, (uchar_t **)&buf,
581 569 (uint_t *)&size) != 0) {
582 570 dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
583 571 RI_HDL_APS));
584 572 goto fail;
585 573 }
586 574
587 575 if (ap_list_unpack(buf, size, &ri_hdl->aps) != 0)
588 576 goto fail;
589 577
590 578 buf = NULL;
591 579 size = 0;
592 580 if (nvlist_lookup_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t **)&buf,
593 581 (uint_t *)&size) != 0) {
594 582 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
595 583 RI_HDL_CPU_CAPS));
596 584 goto fail;
597 585 }
598 586
599 587 if (client_list_unpack(buf, size, &ri_hdl->cpu_cap_clients) != 0)
600 588 goto fail;
601 589
602 590 buf = NULL;
603 591 size = 0;
604 592 if (nvlist_lookup_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t **)&buf,
605 593 (uint_t *)&size) != 0) {
606 594 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
607 595 RI_HDL_MEM_CAPS));
608 596 goto fail;
609 597 }
↓ open down ↓ |
80 lines elided |
↑ open up ↑ |
610 598
611 599 if (client_list_unpack(buf, size, &ri_hdl->mem_cap_clients) != 0)
612 600 goto fail;
613 601
614 602 *hdlp = ri_hdl;
615 603
616 604 return (0);
617 605
618 606 fail:
619 607 free(ri_hdl);
620 - if (nvl != NULL)
621 - nvlist_free(nvl);
608 + nvlist_free(nvl);
622 609
623 610 return (-1);
624 611 }
625 612
626 613 static int
627 614 ap_list_unpack(char *buf, size_t size, ri_ap_t **aps)
628 615 {
629 616 nvpair_t *nvp = NULL;
630 617 nvlist_t *nvl;
631 618 ri_ap_t *aplist = NULL;
632 619 ri_ap_t *prev = NULL;
633 620 ri_ap_t *tmp = NULL;
634 621
635 622 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
636 623 dprintf((stderr, "nvlist_unpack fail\n"));
637 624 return (-1);
638 625 }
639 626
640 627 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
641 628 assert(strcmp(nvpair_name(nvp), RI_AP_T) == 0 &&
642 629 nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
643 630
644 631 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
645 632 dprintf((stderr, "calloc: %s\n", strerror(errno)));
646 633 goto fail;
647 634 }
648 635
649 636 buf = NULL;
650 637 size = 0;
651 638 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
652 639 (uint_t *)&size) != 0) {
653 640 dprintf((stderr, "nvpair_value_byte_array fail\n"));
654 641 goto fail;
655 642 }
656 643
657 644 if (ap_unpack(buf, size, tmp) != 0)
658 645 goto fail;
659 646
660 647 if (aplist == NULL) {
661 648 prev = aplist = tmp;
662 649 } else {
663 650 prev->next = tmp;
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
664 651 prev = tmp;
665 652 }
666 653 }
667 654
668 655 nvlist_free(nvl);
669 656 *aps = aplist;
670 657
671 658 return (0);
672 659
673 660 fail:
674 - if (nvl != NULL)
675 - nvlist_free(nvl);
661 + nvlist_free(nvl);
676 662 if (aplist != NULL) {
677 663 while ((tmp = aplist) != NULL) {
678 664 aplist = aplist->next;
679 665 ri_ap_free(tmp);
680 666 }
681 667 }
682 668
683 669 return (-1);
684 670 }
685 671
686 672 static int
687 673 dev_list_unpack(char *buf, size_t size, ri_dev_t **devs)
688 674 {
689 675 nvpair_t *nvp = NULL;
690 676 nvlist_t *nvl;
691 677 ri_dev_t *devlist = NULL;
692 678 ri_dev_t *prev = NULL;
693 679 ri_dev_t *tmp = NULL;
694 680
695 681 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
696 682 dprintf((stderr, "nvlist_unpack fail\n"));
697 683 return (-1);
698 684 }
699 685
700 686 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
701 687 assert(strcmp(nvpair_name(nvp), RI_DEV_T) == 0 &&
702 688 nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
703 689
704 690 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
705 691 dprintf((stderr, "calloc: %s\n", strerror(errno)));
706 692 goto fail;
707 693 }
708 694
709 695 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
710 696 (uint_t *)&size) != 0) {
711 697 dprintf((stderr, "nvpair_value_byte_array fail\n"));
712 698 goto fail;
713 699 }
714 700
715 701 if (dev_unpack(buf, size, tmp) != 0)
716 702 goto fail;
717 703
718 704 if (devlist == NULL) {
719 705 prev = devlist = tmp;
720 706 } else {
721 707 prev->next = tmp;
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
722 708 prev = tmp;
723 709 }
724 710 }
725 711
726 712 nvlist_free(nvl);
727 713 *devs = devlist;
728 714
729 715 return (0);
730 716
731 717 fail:
732 - if (nvl != NULL)
733 - nvlist_free(nvl);
718 + nvlist_free(nvl);
734 719 if (devlist != NULL) {
735 720 while ((tmp = devlist) != NULL) {
736 721 devlist = devlist->next;
737 722 ri_dev_free(tmp);
738 723 }
739 724 }
740 725
741 726 return (-1);
742 727 }
743 728
744 729 static int
745 730 client_list_unpack(char *buf, size_t size, ri_client_t **clients)
746 731 {
747 732 nvpair_t *nvp = NULL;
748 733 nvlist_t *nvl;
749 734 ri_client_t *client_list = NULL;
750 735 ri_client_t *prev = NULL;
751 736 ri_client_t *tmp = NULL;
752 737
753 738 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
754 739 dprintf((stderr, "nvlist_unpack fail\n"));
755 740 return (-1);
756 741 }
757 742
758 743 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
759 744 assert(strcmp(nvpair_name(nvp), RI_CLIENT_T) == 0);
760 745 assert(nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);
761 746
762 747 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
763 748 dprintf((stderr, "calloc: %s\n", strerror(errno)));
764 749 goto fail;
765 750 }
766 751
767 752 buf = NULL;
768 753 size = 0;
769 754 if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
770 755 (uint_t *)&size) != 0) {
771 756 dprintf((stderr, "nvpair_value_byte_array fail\n"));
772 757 goto fail;
773 758 }
774 759
775 760 if (client_unpack(buf, size, tmp) != 0)
776 761 goto fail;
777 762
778 763 if (client_list == NULL) {
779 764 prev = client_list = tmp;
780 765 } else {
781 766 prev->next = tmp;
↓ open down ↓ |
38 lines elided |
↑ open up ↑ |
782 767 prev = tmp;
783 768 }
784 769 }
785 770
786 771 nvlist_free(nvl);
787 772 *clients = client_list;
788 773
789 774 return (0);
790 775
791 776 fail:
792 - if (nvl != NULL)
793 - nvlist_free(nvl);
777 + nvlist_free(nvl);
794 778 if (client_list != NULL) {
795 779 while ((tmp = client_list) != NULL) {
796 780 client_list = client_list->next;
797 781 ri_client_free(tmp);
798 782 }
799 783 }
800 784
801 785 return (-1);
802 786 }
803 787
804 788 static int
805 789 client_unpack(char *buf, size_t size, ri_client_t *client)
806 790 {
807 791 nvlist_t *nvl;
808 792
809 793 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
810 794 dprintf((stderr, "nvlist_unpack fail\n"));
811 795 return (-1);
812 796 }
813 797
814 798 if (lookup_unpack_byte_array(nvl, RI_CLIENT_USAGE_PROPS,
815 799 &client->usg_props) != 0) {
816 800 nvlist_free(nvl);
817 801 return (-1);
818 802 }
819 803
820 804 #ifdef DEBUG
821 805 nvlist_print(stderr, client->usg_props);
822 806 #endif /* DEBUG */
823 807
824 808 /*
825 809 * Verbose properties for RCM clients only present if
826 810 * RI_VERBOSE was specified for ri_init.
827 811 */
828 812 buf = NULL;
829 813 size = 0;
830 814 if (nvlist_lookup_byte_array(nvl, RI_CLIENT_VERB_PROPS,
831 815 (uchar_t **)&buf, (uint_t *)&size) == 0) {
832 816 if (nvlist_unpack(buf, size, &client->v_props, 0) != 0) {
833 817 dprintf((stderr, "nvlist_unpack fail (%s)\n",
834 818 RI_CLIENT_VERB_PROPS));
835 819 nvlist_free(nvl);
836 820 return (-1);
837 821 }
838 822 }
839 823
840 824 nvlist_free(nvl);
841 825
842 826 return (0);
843 827 }
844 828
845 829 static int
846 830 dev_unpack(char *buf, size_t size, ri_dev_t *dev)
847 831 {
848 832 nvlist_t *nvl;
849 833
850 834 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
851 835 dprintf((stderr, "nvlist_unpack fail\n"));
852 836 return (-1);
853 837 }
854 838
855 839 if (lookup_unpack_byte_array(nvl, RI_DEV_PROPS,
856 840 &dev->conf_props) != 0) {
857 841 nvlist_free(nvl);
858 842 return (-1);
859 843 }
860 844
861 845 #ifdef DEBUG
862 846 nvlist_print(stderr, dev->conf_props);
863 847 #endif /* DEBUG */
864 848
865 849 if (nvlist_lookup_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t **)&buf,
866 850 (uint_t *)&size) != 0) {
867 851 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
868 852 RI_DEV_CLIENTS));
869 853 nvlist_free(nvl);
870 854 return (-1);
871 855 }
872 856
873 857 if (client_list_unpack(buf, size, &dev->rcm_clients) != 0) {
874 858 nvlist_free(nvl);
875 859 return (-1);
876 860 }
877 861
878 862 nvlist_free(nvl);
879 863
880 864 return (0);
881 865 }
882 866
883 867 static int
884 868 ap_unpack(char *buf, size_t size, ri_ap_t *ap)
885 869 {
886 870 nvlist_t *nvl;
887 871
888 872 if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
889 873 dprintf((stderr, "nvlist_unpack fail\n"));
890 874 return (-1);
891 875 }
892 876
893 877 if (lookup_unpack_byte_array(nvl, RI_AP_PROPS, &ap->conf_props) != 0) {
894 878 nvlist_free(nvl);
895 879 return (-1);
896 880 }
897 881
898 882 #ifdef DEBUG
899 883 nvlist_print(stderr, ap->conf_props);
900 884 #endif /* DEBUG */
901 885
902 886 if (nvlist_lookup_byte_array(nvl, RI_AP_CPUS, (uchar_t **)&buf,
903 887 (uint_t *)&size) != 0) {
904 888 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
905 889 RI_AP_CPUS));
906 890 nvlist_free(nvl);
907 891 return (-1);
908 892 }
909 893
910 894 if (dev_list_unpack(buf, size, &ap->cpus) != 0) {
911 895 nvlist_free(nvl);
912 896 return (-1);
913 897 }
914 898
915 899 if (nvlist_lookup_byte_array(nvl, RI_AP_MEMS, (uchar_t **)&buf,
916 900 (uint_t *)&size) != 0) {
917 901 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
918 902 RI_AP_MEMS));
919 903 nvlist_free(nvl);
920 904 return (-1);
921 905 }
922 906
923 907 if (dev_list_unpack(buf, size, &ap->mems) != 0) {
924 908 nvlist_free(nvl);
925 909 return (-1);
926 910 }
927 911
928 912 if (nvlist_lookup_byte_array(nvl, RI_AP_IOS, (uchar_t **)&buf,
929 913 (uint_t *)&size) != 0) {
930 914 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
931 915 RI_AP_IOS));
932 916 nvlist_free(nvl);
933 917 return (-1);
934 918 }
935 919
936 920 if (dev_list_unpack(buf, size, &ap->ios) != 0) {
937 921 nvlist_free(nvl);
938 922 return (-1);
939 923 }
940 924
941 925 nvlist_free(nvl);
942 926
943 927 return (0);
944 928 }
945 929
946 930 /*
947 931 * Lookup byte array in old nvlist_t and unpack into new nvlist_t.
948 932 */
949 933 static int
950 934 lookup_unpack_byte_array(nvlist_t *old_nvl, char *name, nvlist_t **new_nvl)
951 935 {
952 936 char *buf = NULL;
953 937 size_t size = 0;
954 938
955 939 if (nvlist_lookup_byte_array(old_nvl, name, (uchar_t **)&buf,
956 940 (uint_t *)&size) != 0) {
957 941 dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
958 942 name));
959 943 return (-1);
960 944 }
961 945
962 946 if (nvlist_unpack(buf, size, new_nvl, 0) != 0) {
963 947 dprintf((stderr, "nvlist_unpack fail (%s)\n", name));
964 948 return (-1);
965 949 }
966 950
967 951 return (0);
968 952 }
969 953
970 954 ri_ap_t *
971 955 ri_ap_next(ri_hdl_t *hdl, ri_ap_t *ap)
972 956 {
973 957 if (hdl == NULL) {
974 958 errno = EINVAL;
975 959 return (NULL);
976 960 }
977 961 return ((ap == NULL) ? hdl->aps : ap->next);
978 962 }
979 963
980 964 nvlist_t *
981 965 ri_ap_conf_props(ri_ap_t *ap)
982 966 {
983 967 if (ap == NULL) {
984 968 errno = EINVAL;
985 969 return (NULL);
986 970 }
987 971 return (ap->conf_props);
988 972 }
989 973
990 974 ri_dev_t *
991 975 ri_cpu_next(ri_ap_t *ap, ri_dev_t *cpu)
992 976 {
993 977 if (ap == NULL) {
994 978 errno = EINVAL;
995 979 return (NULL);
996 980 }
997 981 return ((cpu == NULL) ? ap->cpus : cpu->next);
998 982 }
999 983
1000 984 ri_dev_t *
1001 985 ri_mem_next(ri_ap_t *ap, ri_dev_t *mem)
1002 986 {
1003 987 if (ap == NULL) {
1004 988 errno = EINVAL;
1005 989 return (NULL);
1006 990 }
1007 991 return ((mem == NULL) ? ap->mems : mem->next);
1008 992 }
1009 993
1010 994 ri_dev_t *
1011 995 ri_io_next(ri_ap_t *ap, ri_dev_t *io)
1012 996 {
1013 997 if (ap == NULL) {
1014 998 errno = EINVAL;
1015 999 return (NULL);
1016 1000 }
1017 1001 return ((io == NULL) ? ap->ios : io->next);
1018 1002 }
1019 1003
1020 1004 ri_client_t *
1021 1005 ri_client_next(ri_dev_t *dev, ri_client_t *rcm_client)
1022 1006 {
1023 1007 if (dev == NULL) {
1024 1008 errno = EINVAL;
1025 1009 return (NULL);
1026 1010 }
1027 1011 return ((rcm_client == NULL) ? dev->rcm_clients : rcm_client->next);
1028 1012 }
1029 1013
1030 1014 nvlist_t *
1031 1015 ri_dev_conf_props(ri_dev_t *dev)
1032 1016 {
1033 1017 if (dev == NULL) {
1034 1018 errno = EINVAL;
1035 1019 return (NULL);
1036 1020 }
1037 1021 return (dev->conf_props);
1038 1022 }
1039 1023
1040 1024 nvlist_t *
1041 1025 ri_client_usage_props(ri_client_t *rcm_client)
1042 1026 {
1043 1027 if (rcm_client == NULL) {
1044 1028 errno = EINVAL;
1045 1029 return (NULL);
1046 1030 }
1047 1031 return (rcm_client->usg_props);
1048 1032 }
1049 1033
1050 1034 nvlist_t *
1051 1035 ri_client_verbose_props(ri_client_t *rcm_client)
1052 1036 {
1053 1037 if (rcm_client == NULL) {
1054 1038 errno = EINVAL;
1055 1039 return (NULL);
1056 1040 }
1057 1041 return (rcm_client->v_props);
1058 1042 }
1059 1043
1060 1044 ri_client_t *
1061 1045 ri_cpu_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
1062 1046 {
1063 1047 if (hdl == NULL) {
1064 1048 errno = EINVAL;
1065 1049 return (NULL);
1066 1050 }
1067 1051 return ((rcm_client == NULL) ? hdl->cpu_cap_clients : rcm_client->next);
1068 1052 }
1069 1053
1070 1054 ri_client_t *
1071 1055 ri_mem_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
1072 1056 {
1073 1057 if (hdl == NULL) {
1074 1058 errno = EINVAL;
1075 1059 return (NULL);
1076 1060 }
1077 1061 return ((rcm_client == NULL) ? hdl->mem_cap_clients : rcm_client->next);
1078 1062 }
↓ open down ↓ |
275 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX