?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8354 sync regcomp(3C) with upstream (fix make catalog)
[unleashed/tickless.git] / usr / src / cmd / dcs / sparc / sun4u / ri_init.c
blob164140fa7cca7d426aa7d141a021558bce9dda8c
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Implementation of ri_init routine for obtaining mapping
28 * of system board attachment points to physical devices and to
29 * the Reconfiguration Coordination Manager (RCM) client usage
30 * of these devices.
31 */
32 #include <string.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <kstat.h>
36 #include <sys/param.h>
37 #include <sys/sbd_ioctl.h>
38 #include "rsrc_info_impl.h"
39
40 /*
41 * Occupant types exported by cfgadm sbd plugin via
42 * config_admin(3CFGADM).
43 */
44 #define SBD_CM_CPU "cpu"
45 #define SBD_CM_MEM "memory"
46 #define SBD_CM_IO "io"
47
48 /*
49 * RCM abstract resource names.
50 */
51 #define RCM_MEM_ALL "SUNW_memory"
52 #define RCM_CPU_ALL "SUNW_cpu"
53 #define RCM_CPU RCM_CPU_ALL"/cpu"
54
55 #define KBYTE 1024
56 #define MBYTE 1048576
57 #define USAGE_ALLOC_SIZE 128
58
59 /*
60 * define to allow io_cm_info to return NODE is NULL to ri_init,
61 * in order to skip over nodes w/unattached drivers
62 */
63 #define RI_NODE_NIL 1
64
65 /*
66 * This code is CMP aware as it parses the
67 * cfgadm info field for individual cpuids.
68 */
69 #define CPUID_SEP ","
70 #define CPU_INFO_FMT "cpuid=%s speed=%d ecache=%d"
71
72 typedef struct {
73 cfga_list_data_t *cfga_list_data;
74 int nlist;
75 } apd_t;
76
77 typedef struct {
78 long pagesize;
79 long syspages;
80 long sysmb;
81 } mem_stat_t;
82
83 #define ms_syspages m_stat.syspages
84 #define ms_pagesize m_stat.pagesize
85 #define ms_sysmb m_stat.sysmb
86
87 typedef int32_t cpuid_t;
88
89 typedef struct {
90 int cpuid_max; /* maximum cpuid value */
91 int ecache_curr; /* cached during tree walk */
92 int *ecache_sizes; /* indexed by cpuid */
93 } ecache_info_t;
94
95 typedef struct {
96 rcm_handle_t *hdl;
97 rcm_info_t *offline_query_info;
98 char **rlist;
99 int nrlist;
100 cpuid_t *cpus;
101 int ncpus;
102 int ndevs;
103 uint_t query_pages;
104 mem_stat_t m_stat;
105 ecache_info_t ecache_info;
106 } rcmd_t;
107
108 typedef struct {
109 const char *rsrc;
110 const char *info;
111 } usage_t;
112
113 /* Lookup table entry for matching IO devices to RCM resource usage */
114 typedef struct {
115 int index; /* index into the table array */
116 di_node_t node; /* associated devinfo node */
117 char *name; /* device full path name */
118 int n_usage;
119 usage_t *usage;
120 } lookup_entry_t;
121
122 typedef struct {
123 int n_entries;
124 int n_slots;
125 lookup_entry_t *table;
126 } lookup_table_t;
127
128 typedef struct {
129 int err;
130 di_node_t node;
131 char *pathbuf;
132 lookup_table_t *table;
133 di_devlink_handle_t linkhd;
134 } devinfo_arg_t;
135
136 static int dyn_ap_ids(char *, cfga_list_data_t **, int *);
137 static int rcm_init(rcmd_t *, apd_t [], int, int);
138 static void rcm_fini(rcmd_t *);
139 static int rcm_query_init(rcmd_t *, apd_t [], int);
140 static int cap_request(ri_hdl_t *, rcmd_t *);
141 static int syscpus(cpuid_t **, int *);
142 static int cpu_cap_request(ri_hdl_t *, rcmd_t *);
143 static int mem_cap_request(ri_hdl_t *, rcmd_t *);
144 static int (*cm_rcm_qpass_func(cfga_type_t))(cfga_list_data_t *, rcmd_t *);
145 static int cpu_rcm_qpass(cfga_list_data_t *, rcmd_t *);
146 static int mem_rcm_qpass(cfga_list_data_t *, rcmd_t *);
147 static int io_rcm_qpass(cfga_list_data_t *, rcmd_t *);
148 static int (*cm_info_func(cfga_type_t))(ri_ap_t *, cfga_list_data_t *, int,
149 rcmd_t *);
150 static int cpu_cm_info(ri_ap_t *, cfga_list_data_t *, int, rcmd_t *);
151 static int i_cpu_cm_info(processorid_t, int, int, ri_ap_t *, rcmd_t *);
152 static int mem_cm_info(ri_ap_t *, cfga_list_data_t *, int, rcmd_t *);
153 static int io_cm_info(ri_ap_t *, cfga_list_data_t *, int, rcmd_t *);
154 static int ident_leaf(di_node_t);
155 static int mk_drv_inst(di_node_t, char [], char *);
156 static int devinfo_node_walk(di_node_t, void *);
157 static int devinfo_minor_walk(di_node_t, di_minor_t, void *);
158 static int devinfo_devlink_walk(di_devlink_t, void *);
159 static int add_rcm_clients(ri_client_t **, rcmd_t *, rcm_info_t *, int, int *);
160 static int rcm_ignore(char *, char *);
161 static int add_query_state(rcmd_t *, ri_client_t *, const char *, const char *);
162 static int state2query(int);
163 static void dev_list_append(ri_dev_t **, ri_dev_t *);
164 static void dev_list_cpu_insert(ri_dev_t **, ri_dev_t *, processorid_t);
165 static rcm_info_tuple_t *tuple_lookup(rcmd_t *, const char *, const char *);
166 static ri_ap_t *ri_ap_alloc(char *, ri_hdl_t *);
167 static ri_dev_t *ri_dev_alloc(void);
168 static ri_dev_t *io_dev_alloc(char *);
169 static ri_client_t *ri_client_alloc(char *, char *);
170 static void apd_tbl_free(apd_t [], int);
171 static char *pstate2str(int);
172 static int ecache_info_init(ecache_info_t *);
173 static int find_cpu_nodes(di_node_t, void *);
174 static int prop_lookup_int(di_node_t, di_prom_handle_t, char *, int **);
175 static int add_lookup_entry(lookup_table_t *, const char *, di_node_t);
176 static int table_compare_names(const void *, const void *);
177 static int table_compare_indices(const void *, const void *);
178 static lookup_entry_t *lookup(lookup_table_t *table, const char *);
179 static int add_usage(lookup_entry_t *, const char *, rcm_info_tuple_t *);
180 static void empty_table(lookup_table_t *);
181
182 #ifdef DEBUG
183 static void dump_apd_tbl(FILE *, apd_t *, int);
184 #endif /* DEBUG */
185
186 static struct {
187 char *type;
188 int (*cm_info)(ri_ap_t *, cfga_list_data_t *, int, rcmd_t *);
189 int (*cm_rcm_qpass)(cfga_list_data_t *, rcmd_t *);
190 } cm_ctl[] = {
191 {SBD_CM_CPU, cpu_cm_info, cpu_rcm_qpass},
192 {SBD_CM_MEM, mem_cm_info, mem_rcm_qpass},
193 {SBD_CM_IO, io_cm_info, io_rcm_qpass}
194 };
195
196 /*
197 * Table of known info string prefixes for RCM modules that do not
198 * represent actual resource usage, but instead provide name translations
199 * or sequencing within the RCM namespace. Since RCM provides no way to
200 * filter these out, we must maintain this hack.
201 */
202 static char *rcm_info_filter[] = {
203 "Network interface", /* Network naming module */
204 NULL
205 };
206
207
208 /*
209 * Allocate snapshot handle.
210 */
211 int
212 ri_init(int n_apids, char **ap_ids, int flags, ri_hdl_t **hdlp)
213 {
214 int i, j;
215 ri_hdl_t *ri_hdl;
216 ri_ap_t *ap_hdl;
217 rcmd_t *rcm = NULL;
218 cfga_list_data_t *cfga_ldata;
219 apd_t *apd, *apd_tbl = NULL;
220 int (*cm_info)(ri_ap_t *, cfga_list_data_t *,
221 int, rcmd_t *);
222 int rv = RI_SUCCESS;
223 int cm_info_rv;
224
225 if (n_apids <= 0 || ap_ids == NULL || hdlp == NULL)
226 return (RI_INVAL);
227
228 if (flags & ~RI_REQ_MASK)
229 return (RI_NOTSUP);
230
231 *hdlp = NULL;
232 if ((ri_hdl = calloc(1, sizeof (*ri_hdl))) == NULL ||
233 (rcm = calloc(1, sizeof (*rcm))) == NULL ||
234 (apd_tbl = calloc(n_apids, sizeof (*apd_tbl))) == NULL) {
235 dprintf((stderr, "calloc: %s\n", strerror(errno)));
236 rv = RI_FAILURE;
237 goto out;
238 }
239
240 /*
241 * Create mapping of boards to components.
242 */
243 for (i = 0, apd = apd_tbl; i < n_apids; i++, apd++) {
244 if (dyn_ap_ids(ap_ids[i], &apd->cfga_list_data,
245 &apd->nlist) == -1) {
246 rv = RI_INVAL;
247 goto out;
248 }
249 }
250 #ifdef DEBUG
251 dump_apd_tbl(stderr, apd_tbl, n_apids);
252 #endif /* DEBUG */
253
254 if (rcm_init(rcm, apd_tbl, n_apids, flags) != 0) {
255 rv = RI_FAILURE;
256 goto out;
257 }
258
259 /*
260 * Best effort attempt to read cpu ecache sizes from
261 * OBP/Solaris device trees. These are later looked up
262 * in i_cpu_cm_info().
263 */
264 (void) ecache_info_init(&rcm->ecache_info);
265
266 for (i = 0, apd = apd_tbl; i < n_apids; i++, apd++) {
267 if ((ap_hdl = ri_ap_alloc(ap_ids[i], ri_hdl)) == NULL) {
268 rv = RI_FAILURE;
269 goto out;
270 }
271
272 /*
273 * Add component info based on occupant type. Note all
274 * passes through the apd table skip over the first
275 * cfgadm_list_data entry, which is the static system board
276 * attachment point.
277 */
278 for (j = 1, cfga_ldata = &apd->cfga_list_data[1];
279 j < apd->nlist; j++, cfga_ldata++) {
280 if (cfga_ldata->ap_o_state != CFGA_STAT_CONFIGURED) {
281 continue;
282 }
283
284 if ((cm_info =
285 cm_info_func(cfga_ldata->ap_type)) != NULL) {
286 cm_info_rv =
287 (*cm_info)(ap_hdl, cfga_ldata, flags, rcm);
288 if (cm_info_rv != 0) {
289 /*
290 * If we cannot obtain info for the ap,
291 * skip it and do not fail the entire
292 * operation. This case occurs when the
293 * driver for a device is not attached:
294 * di_init() returns failed back to
295 * io_cm_info().
296 */
297 if (cm_info_rv == RI_NODE_NIL)
298 continue;
299 else {
300 rv = RI_FAILURE;
301 goto out;
302 }
303 }
304 }
305 }
306 }
307
308 if ((flags & RI_INCLUDE_QUERY) && cap_request(ri_hdl, rcm) != 0)
309 rv = RI_FAILURE;
310
311 out:
312 if (apd_tbl != NULL)
313 apd_tbl_free(apd_tbl, n_apids);
314 if (rcm != NULL)
315 rcm_fini(rcm);
316
317 if (rv == RI_SUCCESS)
318 *hdlp = ri_hdl;
319 else
320 ri_fini(ri_hdl);
321
322 return (rv);
323 }
324
325 /*
326 * Map static board attachment point to dynamic attachment points (components).
327 */
328 static int
329 dyn_ap_ids(char *ap_id, cfga_list_data_t **ap_id_list, int *nlist)
330 {
331 cfga_err_t cfga_err;
332 char *errstr;
333 char *opts = "parsable";
334 char *listops = "class=sbd";
335
336 cfga_err = config_list_ext(1, &ap_id, ap_id_list, nlist,
337 opts, listops, &errstr, CFGA_FLAG_LIST_ALL);
338 if (cfga_err != CFGA_OK) {
339 dprintf((stderr, "config_list_ext: %s\n",
340 config_strerror(cfga_err)));
341 return (-1);
342 }
343
344 return (0);
345 }
346
347 /*
348 * Initialize rcm handle, memory stats. Cache query result if necessary.
349 */
350 static int
351 rcm_init(rcmd_t *rcm, apd_t apd_tbl[], int napds, int flags)
352 {
353 longlong_t ii;
354 int rv = 0;
355
356 rcm->offline_query_info = NULL;
357 rcm->rlist = NULL;
358 rcm->cpus = NULL;
359
360 if (rcm_alloc_handle(NULL, RCM_NOPID, NULL, &rcm->hdl) != RCM_SUCCESS) {
361 dprintf((stderr, "rcm_alloc_handle (errno=%d)\n", errno));
362 return (-1);
363 }
364
365 if ((rcm->ms_pagesize = sysconf(_SC_PAGE_SIZE)) == -1 ||
366 (rcm->ms_syspages = sysconf(_SC_PHYS_PAGES)) == -1) {
367 dprintf((stderr, "sysconf: %s\n", strerror(errno)));
368 return (-1);
369 }
370 ii = (longlong_t)rcm->ms_pagesize * rcm->ms_syspages;
371 rcm->ms_sysmb = (int)((ii+MBYTE-1) / MBYTE);
372
373 if (flags & RI_INCLUDE_QUERY)
374 rv = rcm_query_init(rcm, apd_tbl, napds);
375
376 return (rv);
377 }
378
379 static void
380 rcm_fini(rcmd_t *rcm)
381 {
382 char **cpp;
383
384 assert(rcm != NULL);
385
386 if (rcm->offline_query_info != NULL)
387 rcm_free_info(rcm->offline_query_info);
388 if (rcm->hdl != NULL)
389 rcm_free_handle(rcm->hdl);
390
391 if (rcm->rlist != NULL) {
392 for (cpp = rcm->rlist; *cpp != NULL; cpp++)
393 s_free(*cpp);
394 free(rcm->rlist);
395 }
396
397 s_free(rcm->cpus);
398 free(rcm);
399 }
400
401 #define NODENAME_CMP "cmp"
402 #define NODENAME_SSM "ssm"
403 #define PROP_CPUID "cpuid"
404 #define PROP_DEVICE_TYPE "device-type"
405 #define PROP_ECACHE_SIZE "ecache-size"
406 #define PROP_L2_CACHE_SIZE "l2-cache-size"
407 #define PROP_L3_CACHE_SIZE "l3-cache-size"
408
409 typedef struct {
410 di_node_t root;
411 di_prom_handle_t ph;
412 ecache_info_t *ecache_info;
413 } di_arg_t;
414
415 /*
416 * The ecache sizes for individual cpus are read from the
417 * OBP/Solaris device trees. This info cannot be derived
418 * from the cfgadm_sbd cpu attachment point ecache info,
419 * which may be a sum of multiple cores for CMP.
420 */
421 static int
422 ecache_info_init(ecache_info_t *ec)
423 {
424 di_arg_t di_arg;
425 di_prom_handle_t ph = DI_PROM_HANDLE_NIL;
426 di_node_t root = DI_NODE_NIL;
427 int cpuid_max, rv = 0;
428
429 assert(ec != NULL && ec->cpuid_max == 0 && ec->ecache_sizes == NULL);
430
431 if ((cpuid_max = sysconf(_SC_CPUID_MAX)) == -1) {
432 dprintf((stderr, "sysconf fail: %s\n", strerror(errno)));
433 rv = -1;
434 goto done;
435 }
436
437 if ((root = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
438 dprintf((stderr, "di_init fail: %s\n", strerror(errno)));
439 rv = -1;
440 goto done;
441 }
442
443 if ((ph = di_prom_init()) == DI_PROM_HANDLE_NIL) {
444 dprintf((stderr, "di_prom_init fail: %s\n", strerror(errno)));
445 rv = -1;
446 goto done;
447 }
448
449 if ((ec->ecache_sizes = calloc(cpuid_max + 1, sizeof (int))) == NULL) {
450 dprintf((stderr, "calloc fail: %s\n", strerror(errno)));
451 rv = -1;
452 goto done;
453 }
454 ec->cpuid_max = cpuid_max;
455
456 dprintf((stderr, "cpuid_max is set to %d\n", ec->cpuid_max));
457
458 di_arg.ph = ph;
459 di_arg.root = root;
460 di_arg.ecache_info = ec;
461
462 if (di_walk_node(root, DI_WALK_CLDFIRST, (void *)&di_arg,
463 find_cpu_nodes) != 0) {
464 dprintf((stderr, "di_walk_node fail: %s\n", strerror(errno)));
465 rv = -1;
466 }
467
468 done:
469 if (root != DI_NODE_NIL)
470 di_fini(root);
471 if (ph != DI_PROM_HANDLE_NIL)
472 di_prom_fini(ph);
473
474 return (rv);
475 }
476
477 /*
478 * Libdevinfo node walk callback for reading ecache size
479 * properties for cpu device nodes. Subtrees not containing
480 * cpu nodes are filtered out.
481 */
482 static int
483 find_cpu_nodes(di_node_t node, void *arg)
484 {
485 char *name;
486 int *cpuid, *ecache;
487 di_arg_t *di_arg = (di_arg_t *)arg;
488 ecache_info_t *ec = di_arg->ecache_info;
489 di_prom_handle_t ph = di_arg->ph;
490 int walk_child = 0;
491
492 if (node == DI_NODE_NIL) {
493 return (DI_WALK_TERMINATE);
494 }
495
496 if (node == di_arg->root) {
497 return (DI_WALK_CONTINUE);
498 }
499
500 if (di_nodeid(node) == DI_PSEUDO_NODEID) {
501 return (DI_WALK_PRUNECHILD);
502 }
503
504 name = di_node_name(node);
505 if (name != NULL) {
506 /*
507 * CMP nodes will be the parent of cpu nodes. On some platforms,
508 * cpu nodes will be under the ssm node. In either case,
509 * continue searching this subtree.
510 */
511 if (strncmp(name, NODENAME_SSM, strlen(NODENAME_SSM)) == 0 ||
512 strncmp(name, NODENAME_CMP, strlen(NODENAME_CMP)) == 0) {
513 return (DI_WALK_CONTINUE);
514 }
515 }
516
517 dprintf((stderr, "find_cpu_nodes: node=%p, name=%s, binding_name=%s\n",
518 node, di_node_name(node), di_binding_name(node)));
519
520 /*
521 * Ecache size property name differs with processor implementation.
522 * Panther has both L2 and L3, so check for L3 first to differentiate
523 * from Jaguar, which has only L2.
524 */
525 if (prop_lookup_int(node, ph, PROP_ECACHE_SIZE, &ecache) == 0 ||
526 prop_lookup_int(node, ph, PROP_L3_CACHE_SIZE, &ecache) == 0 ||
527 prop_lookup_int(node, ph, PROP_L2_CACHE_SIZE, &ecache) == 0) {
528 /*
529 * On some platforms the cache property is in the core
530 * node while the cpuid is in the child cpu node. It may
531 * be needed while processing this node or a child node.
532 */
533 ec->ecache_curr = *ecache;
534 walk_child = 1;
535 }
536
537 if (prop_lookup_int(node, ph, PROP_CPUID, &cpuid) == 0) {
538
539 assert(ec != NULL && ec->ecache_sizes != NULL &&
540 *cpuid <= ec->cpuid_max);
541
542 if (ec->ecache_curr != 0) {
543 ec->ecache_sizes[*cpuid] = ec->ecache_curr;
544
545 }
546 }
547
548 return (walk_child ? DI_WALK_CONTINUE : DI_WALK_PRUNECHILD);
549 }
550
551 /*
552 * Given a di_node_t, call the appropriate int property lookup routine.
553 * Note: This lookup fails if the int property has multiple value entries.
554 */
555 static int
556 prop_lookup_int(di_node_t node, di_prom_handle_t ph, char *propname, int **ival)
557 {
558 int rv;
559
560 rv = (di_nodeid(node) == DI_PROM_NODEID) ?
561 di_prom_prop_lookup_ints(ph, node, propname, ival) :
562 di_prop_lookup_ints(DDI_DEV_T_ANY, node, propname, ival);
563
564 return (rv == 1 ? 0 : -1);
565 }
566
567 /*
568 * For offline queries, RCM must be given a list of all resources
569 * so modules can have access to the full scope of the operation.
570 * The rcm_get_info calls are made individually in order to map the
571 * returned rcm_info_t's to physical devices. The rcm_request_offline
572 * result is cached so the query state can be looked up as we process
573 * the rcm_get_info calls. This routine also tallies up the amount of
574 * memory going away and creates a list of cpu ids to be used
575 * later for rcm_request_capacity_change.
576 */
577 static int
578 rcm_query_init(rcmd_t *rcm, apd_t apd_tbl[], int napds)
579 {
580 apd_t *apd;
581 int i, j;
582 cfga_list_data_t *cfga_ldata;
583 int (*cm_rcm_qpass)(cfga_list_data_t *, rcmd_t *);
584 #ifdef DEBUG
585 char **cpp;
586 #endif /* DEBUG */
587
588 /*
589 * Initial pass to size cpu and resource name arrays needed to
590 * interface with RCM. Attachment point ids for CMP can represent
591 * multiple cpus (and resource names). Instead of parsing the
592 * cfgadm info field here, use the worse case that all component
593 * attachment points are CMP.
594 */
595 rcm->ndevs = 0;
596 for (i = 0, apd = apd_tbl; i < napds; i++, apd++) {
597 for (j = 1, cfga_ldata = &apd->cfga_list_data[1];
598 j < apd->nlist; j++, cfga_ldata++) {
599 if (cfga_ldata->ap_o_state != CFGA_STAT_CONFIGURED) {
600 continue;
601 }
602 rcm->ndevs += SBD_MAX_CORES_PER_CMP;
603 }
604 }
605
606 /* account for trailing NULL in rlist */
607 if (rcm->ndevs > 0 &&
608 ((rcm->cpus = calloc(rcm->ndevs, sizeof (cpuid_t))) == NULL ||
609 (rcm->rlist = calloc(rcm->ndevs + 1, sizeof (char *))) == NULL)) {
610 dprintf((stderr, "calloc: %s\n", strerror(errno)));
611 return (-1);
612 }
613
614 /*
615 * Second pass to fill in the RCM resource and cpu lists.
616 */
617 for (i = 0, apd = apd_tbl; i < napds; i++, apd++) {
618 for (j = 1, cfga_ldata = &apd->cfga_list_data[1];
619 j < apd->nlist; j++, cfga_ldata++) {
620 if (cfga_ldata->ap_o_state != CFGA_STAT_CONFIGURED) {
621 continue;
622 }
623 if ((cm_rcm_qpass =
624 cm_rcm_qpass_func(cfga_ldata->ap_type)) != NULL &&
625 (*cm_rcm_qpass)(cfga_ldata, rcm) != 0) {
626 return (-1);
627 }
628 }
629 }
630
631 if (rcm->nrlist == 0)
632 return (0);
633
634 /*
635 * Cache query result. Since we are only interested in the
636 * set of RCM clients processed and not their request status,
637 * the return value is irrelevant.
638 */
639 (void) rcm_request_offline_list(rcm->hdl, rcm->rlist,
640 RCM_QUERY|RCM_SCOPE, &rcm->offline_query_info);
641
642 #ifdef DEBUG
643 dprintf((stderr, "RCM rlist: nrlist=%d\n", rcm->nrlist));
644 for (cpp = rcm->rlist, i = 0; *cpp != NULL; cpp++, i++) {
645 dprintf((stderr, "rlist[%d]=%s\n", i, *cpp));
646 }
647 #endif /* DEBUG */
648
649 return (0);
650 }
651
652 static int
653 cap_request(ri_hdl_t *ri_hdl, rcmd_t *rcm)
654 {
655 return (((rcm->ncpus > 0 && cpu_cap_request(ri_hdl, rcm) != 0) ||
656 (rcm->query_pages > 0 && mem_cap_request(ri_hdl, rcm) != 0)) ?
657 -1 : 0);
658 }
659
660 /*
661 * RCM capacity change request for cpus.
662 */
663 static int
664 cpu_cap_request(ri_hdl_t *ri_hdl, rcmd_t *rcm)
665 {
666 cpuid_t *syscpuids, *newcpuids;
667 int sysncpus, newncpus;
668 rcm_info_t *rcm_info = NULL;
669 int i, j, k;
670 nvlist_t *nvl;
671 int rv = 0;
672
673 /* get all cpus in the system */
674 if (syscpus(&syscpuids, &sysncpus) == -1)
675 return (-1);
676
677 newncpus = sysncpus - rcm->ncpus;
678 if ((newcpuids = calloc(newncpus, sizeof (cpuid_t))) == NULL) {
679 dprintf((stderr, "calloc: %s", strerror(errno)));
680 rv = -1;
681 goto out;
682 }
683
684 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
685 dprintf((stderr, "nvlist_alloc fail\n"));
686 rv = -1;
687 goto out;
688 }
689
690 /*
691 * Construct the new cpu list.
692 */
693 for (i = 0, j = 0; i < sysncpus; i++) {
694 for (k = 0; k < rcm->ncpus; k++) {
695 if (rcm->cpus[k] == syscpuids[i]) {
696 break;
697 }
698 }
699 if (k == rcm->ncpus) {
700 newcpuids[j++] = syscpuids[i];
701 }
702 }
703
704 if (nvlist_add_int32(nvl, "old_total", sysncpus) != 0 ||
705 nvlist_add_int32(nvl, "new_total", newncpus) != 0 ||
706 nvlist_add_int32_array(nvl, "old_cpu_list", syscpuids,
707 sysncpus) != 0 ||
708 nvlist_add_int32_array(nvl, "new_cpu_list", newcpuids,
709 newncpus) != 0) {
710 dprintf((stderr, "nvlist_add fail\n"));
711 rv = -1;
712 goto out;
713 }
714
715 #ifdef DEBUG
716 dprintf((stderr, "old_total=%d\n", sysncpus));
717 for (i = 0; i < sysncpus; i++) {
718 dprintf((stderr, "old_cpu_list[%d]=%d\n", i, syscpuids[i]));
719 }
720 dprintf((stderr, "new_total=%d\n", newncpus));
721 for (i = 0; i < newncpus; i++) {
722 dprintf((stderr, "new_cpu_list[%d]=%d\n", i, newcpuids[i]));
723 }
724 #endif /* DEBUG */
725
726 (void) rcm_request_capacity_change(rcm->hdl, RCM_CPU_ALL,
727 RCM_QUERY|RCM_SCOPE, nvl, &rcm_info);
728
729 rv = add_rcm_clients(&ri_hdl->cpu_cap_clients, rcm, rcm_info, 0, NULL);
730
731 out:
732 s_free(syscpuids);
733 s_free(newcpuids);
734 nvlist_free(nvl);
735 if (rcm_info != NULL)
736 rcm_free_info(rcm_info);
737
738 return (rv);
739 }
740
741 static int
742 syscpus(cpuid_t **cpuids, int *ncpus)
743 {
744 kstat_t *ksp;
745 kstat_ctl_t *kc;
746 cpuid_t *cp;
747 int i;
748
749 if ((*ncpus = sysconf(_SC_NPROCESSORS_CONF)) == -1) {
750 dprintf((stderr, "sysconf: %s\n", errno));
751 return (-1);
752 }
753
754 if ((kc = kstat_open()) == NULL) {
755 dprintf((stderr, "kstat_open fail\n"));
756 return (-1);
757 }
758
759 if ((cp = calloc(*ncpus, sizeof (cpuid_t))) == NULL) {
760 dprintf((stderr, "calloc: %s\n", errno));
761 (void) kstat_close(kc);
762 return (-1);
763 }
764
765 for (i = 0, ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
766 if (strcmp(ksp->ks_module, "cpu_info") == 0) {
767 cp[i++] = ksp->ks_instance;
768 }
769 }
770
771 (void) kstat_close(kc);
772 *cpuids = cp;
773
774 return (0);
775 }
776
777 /*
778 * RCM capacity change request for memory.
779 */
780 static int
781 mem_cap_request(ri_hdl_t *ri_hdl, rcmd_t *rcm)
782 {
783 nvlist_t *nvl;
784 rcm_info_t *rcm_info = NULL;
785 long newpages;
786 int rv = 0;
787
788 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
789 dprintf((stderr, "nvlist_alloc fail\n"));
790 return (-1);
791 }
792
793 newpages = rcm->ms_syspages - rcm->query_pages;
794 if (nvlist_add_int32(nvl, "page_size", rcm->ms_pagesize) != 0 ||
795 nvlist_add_int32(nvl, "old_pages", rcm->ms_syspages) != 0 ||
796 nvlist_add_int32(nvl, "new_pages", newpages) != 0) {
797 dprintf((stderr, "nvlist_add fail\n"));
798 nvlist_free(nvl);
799 return (-1);
800 }
801
802 dprintf((stderr, "memory capacity change req: "
803 "page_size=%d, old_pages=%d, new_pages=%d\n",
804 rcm->ms_pagesize, rcm->ms_syspages, newpages));
805
806 (void) rcm_request_capacity_change(rcm->hdl, RCM_MEM_ALL,
807 RCM_QUERY|RCM_SCOPE, nvl, &rcm_info);
808
809 rv = add_rcm_clients(&ri_hdl->mem_cap_clients, rcm, rcm_info, 0, NULL);
810
811 nvlist_free(nvl);
812 if (rcm_info != NULL)
813 rcm_free_info(rcm_info);
814
815 return (rv);
816 }
817
818 static int
819 (*cm_rcm_qpass_func(cfga_type_t ap_type))(cfga_list_data_t *, rcmd_t *)
820 {
821 int i;
822
823 for (i = 0; i < sizeof (cm_ctl) / sizeof (cm_ctl[0]); i++) {
824 if (strcmp(cm_ctl[i].type, ap_type) == 0) {
825 return (cm_ctl[i].cm_rcm_qpass);
826 }
827 }
828 return (NULL);
829 }
830
831 /*
832 * Save cpu ids and RCM abstract resource names.
833 * Cpu ids will be used for the capacity change request.
834 * Resource names will be used for the offline query.
835 */
836 static int
837 cpu_rcm_qpass(cfga_list_data_t *cfga_ldata, rcmd_t *rcm)
838 {
839 processorid_t cpuid;
840 char *cpustr, *lasts, *rsrcname, rbuf[32];
841 char cbuf[CFGA_INFO_LEN];
842 int speed, ecache;
843
844 assert(sscanf(cfga_ldata->ap_info, CPU_INFO_FMT, &cbuf, &speed,
845 &ecache) == 3);
846
847 for (cpustr = (char *)strtok_r(cbuf, CPUID_SEP, &lasts);
848 cpustr != NULL;
849 cpustr = (char *)strtok_r(NULL, CPUID_SEP, &lasts)) {
850 cpuid = atoi(cpustr);
851
852 (void) snprintf(rbuf, sizeof (rbuf), "%s%d", RCM_CPU, cpuid);
853 if ((rsrcname = strdup(rbuf)) == NULL) {
854 dprintf((stderr, "strdup fail\n"));
855 return (-1);
856 }
857 assert(rcm->nrlist < rcm->ndevs && rcm->ncpus < rcm->ndevs);
858 rcm->rlist[rcm->nrlist++] = rsrcname;
859 rcm->cpus[rcm->ncpus++] = (cpuid_t)cpuid;
860
861 dprintf((stderr, "cpu_cm_info: cpuid=%d, rsrcname=%s",
862 cpuid, rsrcname));
863 }
864
865 return (0);
866 }
867
868 /*
869 * No RCM resource names for individual memory units, so
870 * just add to offline query page count.
871 */
872 static int
873 mem_rcm_qpass(cfga_list_data_t *cfga, rcmd_t *rcm)
874 {
875 char *cp;
876 uint_t kbytes;
877 longlong_t ii;
878
879 if ((cp = strstr(cfga->ap_info, "size")) == NULL ||
880 sscanf(cp, "size=%u", &kbytes) != 1) {
881 dprintf((stderr, "unknown sbd info format: %s\n", cp));
882 return (-1);
883 }
884
885 ii = (longlong_t)kbytes * KBYTE;
886 rcm->query_pages += (uint_t)(ii / rcm->ms_pagesize);
887
888 dprintf((stderr, "%s: npages=%u\n", cfga->ap_log_id,
889 (uint_t)(ii / rcm->ms_pagesize)));
890
891 return (0);
892 }
893
894 /*
895 * Add physical I/O bus name to RCM resource list.
896 */
897 static int
898 io_rcm_qpass(cfga_list_data_t *cfga, rcmd_t *rcm)
899 {
900 char path[MAXPATHLEN];
901 char buf[MAXPATHLEN];
902 char *rsrcname;
903
904 if (sscanf(cfga->ap_info, "device=%s", path) != 1) {
905 dprintf((stderr, "unknown sbd info format: %s\n",
906 cfga->ap_info));
907 return (-1);
908 }
909
910 (void) snprintf(buf, sizeof (buf), "/devices%s", path);
911 if ((rsrcname = strdup(buf)) == NULL) {
912 dprintf((stderr, "strdup fail\n"));
913 return (-1);
914 }
915
916 assert(rcm->nrlist < rcm->ndevs);
917 rcm->rlist[rcm->nrlist++] = rsrcname;
918
919 return (0);
920 }
921
922 static int
923 (*cm_info_func(cfga_type_t ap_type))(ri_ap_t *, cfga_list_data_t *,
924 int, rcmd_t *)
925 {
926 int i;
927
928 for (i = 0; i < sizeof (cm_ctl) / sizeof (cm_ctl[0]); i++) {
929 if (strcmp(cm_ctl[i].type, ap_type) == 0) {
930 return (cm_ctl[i].cm_info);
931 }
932 }
933 return (NULL);
934 }
935
936 /*
937 * Create cpu handle, adding properties exported by sbd plugin and
938 * RCM client usage.
939 */
940 /* ARGSUSED */
941 static int
942 cpu_cm_info(ri_ap_t *ap, cfga_list_data_t *cfga, int flags, rcmd_t *rcm)
943 {
944 processorid_t cpuid;
945 int speed, ecache, rv = 0;
946 char buf[CFGA_INFO_LEN], *cpustr, *lasts;
947
948 if (sscanf(cfga->ap_info, CPU_INFO_FMT, &buf, &speed, &ecache) != 3) {
949 dprintf((stderr, "unknown sbd info format: %s\n",
950 cfga->ap_info));
951 return (-1);
952 }
953
954 /* parse cpuids */
955 for (cpustr = (char *)strtok_r(buf, CPUID_SEP, &lasts);
956 cpustr != NULL;
957 cpustr = (char *)strtok_r(NULL, CPUID_SEP, &lasts)) {
958 cpuid = atoi(cpustr);
959 if ((rv = i_cpu_cm_info(cpuid, speed, ecache, ap, rcm)) != 0) {
960 break;
961 }
962 }
963
964 return (rv);
965 }
966
967 static int
968 i_cpu_cm_info(processorid_t cpuid, int speed, int ecache_cfga, ri_ap_t *ap,
969 rcmd_t *rcm)
970 {
971 int ecache_mb = 0;
972 int ecache_kb = 0;
973 char *state, buf[32];
974 processor_info_t cpu_info;
975 ri_dev_t *cpu = NULL;
976 rcm_info_t *rcm_info = NULL;
977
978 /*
979 * Could have been unconfigured in the interim, so cannot
980 * count on processor_info recognizing it.
981 */
982 state = (processor_info(cpuid, &cpu_info) == 0) ?
983 pstate2str(cpu_info.pi_state) : "unknown";
984
985 if ((cpu = ri_dev_alloc()) == NULL) {
986 dprintf((stderr, "ri_dev_alloc failed\n"));
987 return (-1);
988 }
989
990 /*
991 * Assume the ecache_info table has the right e-cache size for
992 * this CPU. Use the value found in cfgadm (ecache_cfga) if not.
993 */
994 if (rcm->ecache_info.ecache_sizes != NULL) {
995 assert(rcm->ecache_info.cpuid_max != 0 &&
996 cpuid <= rcm->ecache_info.cpuid_max);
997 ecache_mb = rcm->ecache_info.ecache_sizes[cpuid] / MBYTE;
998 ecache_kb = rcm->ecache_info.ecache_sizes[cpuid] / KBYTE;
999 }
1000
1001 if (ecache_mb == 0) {
1002 ecache_mb = ecache_cfga;
1003 }
1004
1005 dprintf((stderr, "i_cpu_cm_info: cpu(%d) ecache=%d MB\n",
1006 cpuid, ecache));
1007
1008 if (nvlist_add_int32(cpu->conf_props, RI_CPU_ID, cpuid) != 0 ||
1009 nvlist_add_int32(cpu->conf_props, RI_CPU_SPEED, speed) != 0 ||
1010 nvlist_add_int32(cpu->conf_props, RI_CPU_ECACHE, ecache_mb) != 0 ||
1011 nvlist_add_string(cpu->conf_props, RI_CPU_STATE, state) != 0) {
1012 dprintf((stderr, "nvlist_add fail\n"));
1013 ri_dev_free(cpu);
1014 return (-1);
1015 }
1016
1017 /*
1018 * Report cache size in kilobyte units if available. This info is
1019 * added to support processors with cache sizes that are non-integer
1020 * megabyte multiples.
1021 */
1022 if (ecache_kb != 0) {
1023 if (nvlist_add_int32(cpu->conf_props, RI_CPU_ECACHE_KBYTE,
1024 ecache_kb) != 0) {
1025 dprintf((stderr, "nvlist_add fail: %s\n",
1026 RI_CPU_ECACHE_KBYTE));
1027 ri_dev_free(cpu);
1028 return (-1);
1029 }
1030 }
1031
1032 (void) snprintf(buf, sizeof (buf), "%s%d", RCM_CPU, cpuid);
1033 dprintf((stderr, "rcm_get_info(%s)\n", buf));
1034 if (rcm_get_info(rcm->hdl, buf, RCM_INCLUDE_DEPENDENT,
1035 &rcm_info) != RCM_SUCCESS) {
1036 dprintf((stderr, "rcm_get_info (errno=%d)\n", errno));
1037 ri_dev_free(cpu);
1038 if (rcm_info != NULL)
1039 rcm_free_info(rcm_info);
1040 return (-1);
1041 }
1042
1043 dev_list_cpu_insert(&ap->cpus, cpu, cpuid);
1044
1045 return (0);
1046 }
1047
1048 /*
1049 * Create memory handle, adding properties exported by sbd plugin.
1050 * No RCM tuples to be saved unless RCM is modified to export names
1051 * for individual memory units.
1052 */
1053 /* ARGSUSED */
1054 static int
1055 mem_cm_info(ri_ap_t *ap, cfga_list_data_t *cfga, int flags, rcmd_t *rcm)
1056 {
1057 ri_dev_t *mem;
1058 char *cp;
1059 char *cpval;
1060 int len;
1061 uint64_t base_addr; /* required */
1062 int32_t size_kb; /* required */
1063 int32_t perm_kb = 0; /* optional */
1064 char target[CFGA_AP_LOG_ID_LEN] = ""; /* optional */
1065 int32_t del_kb = 0; /* optional */
1066 int32_t rem_kb = 0; /* optional */
1067 char source[CFGA_AP_LOG_ID_LEN] = ""; /* optional */
1068
1069 if (sscanf(cfga->ap_info, "address=0x%llx size=%u", &base_addr,
1070 &size_kb) != 2) {
1071 goto err_fmt;
1072 }
1073
1074 if ((cp = strstr(cfga->ap_info, "permanent")) != NULL &&
1075 sscanf(cp, "permanent=%u", &perm_kb) != 1) {
1076 goto err_fmt;
1077 }
1078
1079 if ((cp = strstr(cfga->ap_info, "target")) != NULL) {
1080 if ((cpval = strstr(cp, "=")) == NULL) {
1081 goto err_fmt;
1082 }
1083 for (len = 0; cpval[len] != '\0' && cpval[len] != ' '; len++) {
1084 if (len >= CFGA_AP_LOG_ID_LEN) {
1085 goto err_fmt;
1086 }
1087 }
1088 if (sscanf(cp, "target=%s deleted=%u remaining=%u", &target,
1089 &del_kb, &rem_kb) != 3) {
1090 goto err_fmt;
1091 }
1092 }
1093
1094 if ((cp = strstr(cfga->ap_info, "source")) != NULL) {
1095 if ((cpval = strstr(cp, "=")) == NULL) {
1096 goto err_fmt;
1097 }
1098 for (len = 0; cpval[len] != '\0' && cpval[len] != ' '; len++) {
1099 if (len >= CFGA_AP_LOG_ID_LEN) {
1100 goto err_fmt;
1101 }
1102 }
1103 if (sscanf(cp, "source=%s", &source) != 1) {
1104 goto err_fmt;
1105 }
1106 }
1107
1108 dprintf((stderr, "%s: base=0x%llx, size=%u, permanent=%u\n",
1109 cfga->ap_log_id, base_addr, size_kb, perm_kb));
1110
1111 if ((mem = ri_dev_alloc()) == NULL)
1112 return (-1);
1113
1114 /*
1115 * Convert memory sizes to MB (truncate).
1116 */
1117 if (nvlist_add_uint64(mem->conf_props, RI_MEM_ADDR, base_addr) != 0 ||
1118 nvlist_add_int32(mem->conf_props, RI_MEM_BRD, size_kb/KBYTE) != 0 ||
1119 nvlist_add_int32(mem->conf_props, RI_MEM_PERM,
1120 perm_kb/KBYTE) != 0) {
1121 dprintf((stderr, "nvlist_add failure\n"));
1122 ri_dev_free(mem);
1123 return (-1);
1124 }
1125
1126 if (target[0] != '\0' &&
1127 (nvlist_add_string(mem->conf_props, RI_MEM_TARG, target) != 0 ||
1128 nvlist_add_int32(mem->conf_props, RI_MEM_DEL, del_kb/KBYTE) != 0 ||
1129 nvlist_add_int32(mem->conf_props, RI_MEM_REMAIN,
1130 rem_kb/KBYTE) != 0)) {
1131 dprintf((stderr, "nvlist_add failure\n"));
1132 ri_dev_free(mem);
1133 return (-1);
1134 }
1135
1136 if (source[0] != '\0' &&
1137 nvlist_add_string(mem->conf_props, RI_MEM_SRC, source) != 0) {
1138 dprintf((stderr, "nvlist_add failure\n"));
1139 ri_dev_free(mem);
1140 return (-1);
1141 }
1142
1143 /*
1144 * XXX - move this property to attachment point hdl?
1145 */
1146 if (nvlist_add_int32(mem->conf_props, RI_MEM_DOMAIN,
1147 rcm->ms_sysmb) != 0) {
1148 dprintf((stderr, "nvlist_add failure\n"));
1149 ri_dev_free(mem);
1150 return (-1);
1151 }
1152
1153 dev_list_append(&ap->mems, mem);
1154 return (0);
1155
1156 err_fmt:
1157 dprintf((stderr, "unknown sbd info format: %s\n", cfga->ap_info));
1158 return (-1);
1159 }
1160
1161 /*
1162 * Initiate a libdevinfo walk on the IO bus path.
1163 * XXX - investigate performance using two threads here: one thread to do the
1164 * libdevinfo snapshot and treewalk; and one thread to get RCM usage info
1165 */
1166 static int
1167 io_cm_info(ri_ap_t *ap, cfga_list_data_t *cfga, int flags, rcmd_t *rcm)
1168 {
1169 int i;
1170 int j;
1171 int k;
1172 int set_size;
1173 int retval = 0;
1174 int n_usage;
1175 devinfo_arg_t di_arg;
1176 lookup_table_t devicetable;
1177 lookup_entry_t *deventry;
1178 lookup_entry_t *lastdeventry;
1179 ri_dev_t *io = NULL;
1180 ri_client_t *client;
1181 ri_client_t *tmp;
1182 di_devlink_handle_t linkhd = NULL;
1183 di_node_t root = DI_NODE_NIL;
1184 di_node_t node = DI_NODE_NIL;
1185 rcm_info_tuple_t *rcm_tuple;
1186 rcm_info_t *rcm_info = NULL;
1187 const char *rcm_rsrc = NULL;
1188 char drv_inst[MAXPATHLEN];
1189 char path[MAXPATHLEN];
1190 char pathbuf[MAXPATHLEN];
1191
1192 dprintf((stderr, "io_cm_info(%s)\n", cfga->ap_log_id));
1193
1194 /* Extract devfs path from cfgadm information */
1195 if (sscanf(cfga->ap_info, "device=%s\n", path) != 1) {
1196 dprintf((stderr, "unknown sbd info format: %s\n",
1197 cfga->ap_info));
1198 return (-1);
1199 }
1200
1201 /* Initialize empty device lookup table */
1202 devicetable.n_entries = 0;
1203 devicetable.n_slots = 0;
1204 devicetable.table = NULL;
1205
1206 /* Get libdevinfo snapshot */
1207 dprintf((stderr, "di_init(%s)\n", path));
1208 if ((root = di_init(path, DINFOCPYALL)) == DI_NODE_NIL) {
1209 dprintf((stderr, "di_init: %s\n", strerror(errno)));
1210 retval = RI_NODE_NIL; /* tell ri_init to skip this node */
1211 goto end;
1212 }
1213
1214 /*
1215 * Map in devlinks database.
1216 * XXX - This could be moved to ri_init() for better performance.
1217 */
1218 dprintf((stderr, "di_devlink_init()\n"));
1219 if ((linkhd = di_devlink_init(NULL, 0)) == NULL) {
1220 dprintf((stderr, "di_devlink_init: %s\n", strerror(errno)));
1221 retval = -1;
1222 goto end;
1223 }
1224
1225 /* Initialize argument for devinfo treewalk */
1226 di_arg.err = 0;
1227 di_arg.node = DI_NODE_NIL;
1228 di_arg.pathbuf = pathbuf;
1229 di_arg.table = &devicetable;
1230 di_arg.linkhd = linkhd;
1231
1232 /* Use libdevinfo treewalk to build device lookup table */
1233 if (di_walk_node(root, DI_WALK_CLDFIRST, (void *)&di_arg,
1234 devinfo_node_walk) != 0) {
1235 dprintf((stderr, "di_walk_node: %s\n", strerror(errno)));
1236 retval = -1;
1237 goto end;
1238 }
1239 if (di_arg.err != 0) {
1240 dprintf((stderr, "di_walk_node: device tree walk failed\n"));
1241 retval = -1;
1242 goto end;
1243 }
1244
1245 /* Call RCM to gather usage information */
1246 (void) snprintf(pathbuf, MAXPATHLEN, "/devices%s", path);
1247 dprintf((stderr, "rcm_get_info(%s)\n", pathbuf));
1248 if (rcm_get_info(rcm->hdl, pathbuf,
1249 RCM_INCLUDE_SUBTREE|RCM_INCLUDE_DEPENDENT, &rcm_info) !=
1250 RCM_SUCCESS) {
1251 dprintf((stderr, "rcm_get_info (errno=%d)\n", errno));
1252 retval = -1;
1253 goto end;
1254 }
1255
1256 /* Sort the device table by name (proper order for lookups) */
1257 qsort(devicetable.table, devicetable.n_entries, sizeof (lookup_entry_t),
1258 table_compare_names);
1259
1260 /* Perform mappings of RCM usage segments to device table entries */
1261 lastdeventry = NULL;
1262 rcm_tuple = NULL;
1263 while ((rcm_tuple = rcm_info_next(rcm_info, rcm_tuple)) != NULL) {
1264 if ((rcm_rsrc = rcm_info_rsrc(rcm_tuple)) == NULL)
1265 continue;
1266 if (deventry = lookup(&devicetable, rcm_rsrc)) {
1267 if (add_usage(deventry, rcm_rsrc, rcm_tuple)) {
1268 retval = -1;
1269 goto end;
1270 }
1271 lastdeventry = deventry;
1272 } else {
1273 if (add_usage(lastdeventry, rcm_rsrc, rcm_tuple)) {
1274 retval = -1;
1275 goto end;
1276 }
1277 }
1278 }
1279
1280 /* Re-sort the device table by index number (original treewalk order) */
1281 qsort(devicetable.table, devicetable.n_entries, sizeof (lookup_entry_t),
1282 table_compare_indices);
1283
1284 /*
1285 * Use the mapped usage and the device table to construct ri_dev_t's.
1286 * Construct one for each set of entries in the device table with
1287 * matching di_node_t's, if: 1) it has mapped RCM usage, or 2) it is
1288 * a leaf node and the caller has requested that unmanaged nodes be
1289 * included in the output.
1290 */
1291 i = 0;
1292 while (i < devicetable.n_entries) {
1293
1294 node = devicetable.table[i].node;
1295
1296 /* Count how many usage records are mapped to this node's set */
1297 n_usage = 0;
1298 set_size = 0;
1299 while (((i + set_size) < devicetable.n_entries) &&
1300 (devicetable.table[i + set_size].node == node)) {
1301 n_usage += devicetable.table[i + set_size].n_usage;
1302 set_size += 1;
1303 }
1304
1305 /*
1306 * If there's no usage, then the node is unmanaged. Skip this
1307 * set of devicetable entries unless the node is a leaf node
1308 * and the caller has requested information on unmanaged leaves.
1309 */
1310 if ((n_usage == 0) &&
1311 !((flags & RI_INCLUDE_UNMANAGED) && (ident_leaf(node)))) {
1312 i += set_size;
1313 continue;
1314 }
1315
1316 /*
1317 * The checks above determined that this node is going in.
1318 * So determine its driver/instance name and allocate an
1319 * ri_dev_t for this node.
1320 */
1321 if (mk_drv_inst(node, drv_inst, devicetable.table[i].name)) {
1322 dprintf((stderr, "mk_drv_inst failed\n"));
1323 retval = -1;
1324 break;
1325 }
1326 if ((io = io_dev_alloc(drv_inst)) == NULL) {
1327 dprintf((stderr, "io_dev_alloc failed\n"));
1328 retval = -1;
1329 break;
1330 }
1331
1332 /* Now add all the RCM usage records (if any) to the ri_dev_t */
1333 for (j = i; j < (i + set_size); j++) {
1334 for (k = 0; k < devicetable.table[j].n_usage; k++) {
1335 /* Create new ri_client_t for basic usage */
1336 client = ri_client_alloc(
1337 (char *)devicetable.table[j].usage[k].rsrc,
1338 (char *)devicetable.table[j].usage[k].info);
1339 if (client == NULL) {
1340 dprintf((stderr,
1341 "ri_client_alloc failed\n"));
1342 ri_dev_free(io);
1343 retval = -1;
1344 goto end;
1345 }
1346
1347 /* Add extra query usage to the ri_client_t */
1348 if ((flags & RI_INCLUDE_QUERY) &&
1349 (add_query_state(rcm, client,
1350 devicetable.table[j].usage[k].rsrc,
1351 devicetable.table[j].usage[k].info) != 0)) {
1352 dprintf((stderr,
1353 "add_query_state failed\n"));
1354 ri_dev_free(io);
1355 ri_client_free(client);
1356 retval = -1;
1357 goto end;
1358 }
1359
1360 /* Link new ri_client_t to ri_dev_t */
1361 if (io->rcm_clients) {
1362 tmp = io->rcm_clients;
1363 while (tmp->next)
1364 tmp = tmp->next;
1365 tmp->next = client;
1366 } else {
1367 io->rcm_clients = client;
1368 }
1369 }
1370 }
1371
1372 /* Link the ri_dev_t into the return value */
1373 dev_list_append(&ap->ios, io);
1374
1375 /* Advance to the next node set */
1376 i += set_size;
1377 }
1378
1379 end:
1380 if (rcm_info != NULL)
1381 rcm_free_info(rcm_info);
1382 if (linkhd != NULL)
1383 di_devlink_fini(&linkhd);
1384 if (root != DI_NODE_NIL)
1385 di_fini(root);
1386 empty_table(&devicetable);
1387
1388 dprintf((stderr, "io_cm_info: returning %d\n", retval));
1389 return (retval);
1390 }
1391
1392 static int
1393 ident_leaf(di_node_t node)
1394 {
1395 di_minor_t minor = DI_MINOR_NIL;
1396
1397 return ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL &&
1398 di_child_node(node) == DI_NODE_NIL);
1399 }
1400
1401 /* ARGSUSED */
1402 static int
1403 mk_drv_inst(di_node_t node, char drv_inst[], char *devfs_path)
1404 {
1405 char *drv;
1406 int inst;
1407
1408 if ((drv = di_driver_name(node)) == NULL) {
1409 dprintf((stderr, "no driver bound to %s\n",
1410 devfs_path));
1411 return (-1);
1412 }
1413
1414 if ((inst = di_instance(node)) == -1) {
1415 dprintf((stderr, "no instance assigned to %s\n",
1416 devfs_path));
1417 return (-1);
1418 }
1419 (void) snprintf(drv_inst, MAXPATHLEN, "%s%d", drv, inst);
1420
1421 return (0);
1422 }
1423
1424 /*
1425 * Libdevinfo walker.
1426 *
1427 * During the tree walk of the attached IO devices, for each node
1428 * and all of its associated minors, the following actions are performed:
1429 * - The /devices path of the physical device node or minor
1430 * is stored in a lookup table along with a reference to the
1431 * libdevinfo node it represents via add_lookup_entry().
1432 * - The device links associated with each device are also
1433 * stored in the same lookup table along with a reference to
1434 * the libdevinfo node it represents via the minor walk callback.
1435 *
1436 */
1437 static int
1438 devinfo_node_walk(di_node_t node, void *arg)
1439 {
1440 char *devfs_path;
1441 #ifdef DEBUG
1442 char *drv;
1443 #endif /* DEBUG */
1444 devinfo_arg_t *di_arg = (devinfo_arg_t *)arg;
1445
1446 if (node == DI_NODE_NIL) {
1447 return (DI_WALK_TERMINATE);
1448 }
1449
1450 if (((di_state(node) & DI_DRIVER_DETACHED) == 0) &&
1451 ((devfs_path = di_devfs_path(node)) != NULL)) {
1452
1453 /* Use the provided path buffer to create full /devices path */
1454 (void) snprintf(di_arg->pathbuf, MAXPATHLEN, "/devices%s",
1455 devfs_path);
1456
1457 #ifdef DEBUG
1458 dprintf((stderr, "devinfo_node_walk(%s)\n", di_arg->pathbuf));
1459 if ((drv = di_driver_name(node)) != NULL)
1460 dprintf((stderr, " driver name %s instance %d\n", drv,
1461 di_instance(node)));
1462 #endif
1463
1464 /* Free the devfs_path */
1465 di_devfs_path_free(devfs_path);
1466
1467 /* Add an entry to the lookup table for this physical device */
1468 if (add_lookup_entry(di_arg->table, di_arg->pathbuf, node)) {
1469 dprintf((stderr, "add_lookup_entry: %s\n",
1470 strerror(errno)));
1471 di_arg->err = 1;
1472 return (DI_WALK_TERMINATE);
1473 }
1474
1475 /* Check if this node has minors */
1476 if ((di_minor_next(node, DI_MINOR_NIL)) != DI_MINOR_NIL) {
1477 /* Walk this node's minors */
1478 di_arg->node = node;
1479 if (di_walk_minor(node, NULL, DI_CHECK_ALIAS, arg,
1480 devinfo_minor_walk) != 0) {
1481 dprintf((stderr, "di_walk_minor: %s\n",
1482 strerror(errno)));
1483 di_arg->err = 1;
1484 return (DI_WALK_TERMINATE);
1485 }
1486 }
1487 }
1488
1489 return (DI_WALK_CONTINUE);
1490 }
1491
1492 /*
1493 * Use di_devlink_walk to find the /dev link from /devices path for this minor
1494 */
1495 static int
1496 devinfo_minor_walk(di_node_t node, di_minor_t minor, void *arg)
1497 {
1498 char *name;
1499 char *devfs_path;
1500 devinfo_arg_t *di_arg = (devinfo_arg_t *)arg;
1501 char pathbuf[MAXPATHLEN];
1502
1503 #ifdef DEBUG
1504 dprintf((stderr, "devinfo_minor_walk(%d) %s\n", minor,
1505 di_arg->pathbuf));
1506
1507 if ((name = di_minor_name(minor)) != NULL) {
1508 dprintf((stderr, " minor name %s\n", name));
1509 }
1510 #endif /* DEBUG */
1511
1512 /* Terminate the walk when the device node changes */
1513 if (node != di_arg->node) {
1514 return (DI_WALK_TERMINATE);
1515 }
1516
1517 /* Construct full /devices path for this minor */
1518 if ((name = di_minor_name(minor)) == NULL) {
1519 return (DI_WALK_CONTINUE);
1520 }
1521 (void) snprintf(pathbuf, MAXPATHLEN, "%s:%s", di_arg->pathbuf, name);
1522
1523 /* Add lookup entry for this minor node */
1524 if (add_lookup_entry(di_arg->table, pathbuf, node)) {
1525 dprintf((stderr, "add_lookup_entry: %s\n", strerror(errno)));
1526 di_arg->err = 1;
1527 return (DI_WALK_TERMINATE);
1528 }
1529
1530 /*
1531 * Walk the associated device links.
1532 * Note that di_devlink_walk() doesn't want "/devices" in its paths.
1533 * Also note that di_devlink_walk() will fail if there are no device
1534 * links, which is fine; so ignore if it fails. Only check for
1535 * internal failures during such a walk.
1536 */
1537 devfs_path = &pathbuf[strlen("/devices")];
1538 (void) di_devlink_walk(di_arg->linkhd, NULL, devfs_path, 0, arg,
1539 devinfo_devlink_walk);
1540 if (di_arg->err != 0) {
1541 return (DI_WALK_TERMINATE);
1542 }
1543
1544 return (DI_WALK_CONTINUE);
1545 }
1546
1547 static int
1548 devinfo_devlink_walk(di_devlink_t devlink, void *arg)
1549 {
1550 const char *linkpath;
1551 devinfo_arg_t *di_arg = (devinfo_arg_t *)arg;
1552
1553 /* Get the devlink's path */
1554 if ((linkpath = di_devlink_path(devlink)) == NULL) {
1555 dprintf((stderr, "di_devlink_path: %s\n", strerror(errno)));
1556 di_arg->err = 1;
1557 return (DI_WALK_TERMINATE);
1558 }
1559 dprintf((stderr, "devinfo_devlink_walk: %s\n", linkpath));
1560
1561 /* Add lookup entry for this devlink */
1562 if (add_lookup_entry(di_arg->table, linkpath, di_arg->node)) {
1563 dprintf((stderr, "add_lookup_entry: %s\n", strerror(errno)));
1564 di_arg->err = 1;
1565 return (DI_WALK_TERMINATE);
1566 }
1567
1568 return (DI_WALK_CONTINUE);
1569 }
1570
1571 /*
1572 * Map rcm_info_t's to ri_client_t's, filtering out "uninteresting" (hack)
1573 * RCM clients. The number of "interesting" ri_client_t's is returned
1574 * in cnt if passed non-NULL.
1575 */
1576 static int
1577 add_rcm_clients(ri_client_t **client_list, rcmd_t *rcm, rcm_info_t *info,
1578 int flags, int *cnt)
1579 {
1580 rcm_info_tuple_t *tuple;
1581 char *rsrc, *usage;
1582 ri_client_t *client, *tmp;
1583
1584 assert(client_list != NULL && rcm != NULL);
1585
1586 if (info == NULL)
1587 return (0);
1588
1589 if (cnt != NULL)
1590 *cnt = 0;
1591
1592 tuple = NULL;
1593 while ((tuple = rcm_info_next(info, tuple)) != NULL) {
1594 if ((rsrc = (char *)rcm_info_rsrc(tuple)) == NULL ||
1595 (usage = (char *)rcm_info_info(tuple)) == NULL) {
1596 continue;
1597 }
1598
1599 if (rcm_ignore(rsrc, usage) == 0)
1600 continue;
1601
1602 if ((client = ri_client_alloc(rsrc, usage)) == NULL)
1603 return (-1);
1604
1605 if ((flags & RI_INCLUDE_QUERY) && add_query_state(rcm, client,
1606 rsrc, usage) != 0) {
1607 ri_client_free(client);
1608 return (-1);
1609 }
1610
1611 if (cnt != NULL)
1612 ++*cnt;
1613
1614 /*
1615 * Link in
1616 */
1617 if ((tmp = *client_list) == NULL) {
1618 *client_list = client;
1619 continue;
1620 }
1621 while (tmp->next != NULL) {
1622 tmp = tmp->next;
1623 }
1624 tmp->next = client;
1625 }
1626
1627 return (0);
1628 }
1629
1630 /*
1631 * Currently only filtering out based on known info string prefixes.
1632 */
1633 /* ARGSUSED */
1634 static int
1635 rcm_ignore(char *rsrc, char *infostr)
1636 {
1637 char **cpp;
1638
1639 for (cpp = rcm_info_filter; *cpp != NULL; cpp++) {
1640 if (strncmp(infostr, *cpp, strlen(*cpp)) == 0) {
1641 return (0);
1642 }
1643 }
1644 return (-1);
1645 }
1646
1647 /*
1648 * If this tuple was cached in the offline query pass, add the
1649 * query state and error string to the ri_client_t.
1650 */
1651 static int
1652 add_query_state(rcmd_t *rcm, ri_client_t *client, const char *rsrc,
1653 const char *info)
1654 {
1655 int qstate = RI_QUERY_UNKNOWN;
1656 char *errstr = NULL;
1657 rcm_info_tuple_t *cached_tuple;
1658
1659 if ((cached_tuple = tuple_lookup(rcm, rsrc, info)) != NULL) {
1660 qstate = state2query(rcm_info_state(cached_tuple));
1661 errstr = (char *)rcm_info_error(cached_tuple);
1662 }
1663
1664 if (nvlist_add_int32(client->usg_props, RI_QUERY_STATE, qstate) != 0 ||
1665 (errstr != NULL && nvlist_add_string(client->usg_props,
1666 RI_QUERY_ERR, errstr) != 0)) {
1667 dprintf((stderr, "nvlist_add fail\n"));
1668 return (-1);
1669 }
1670
1671 return (0);
1672 }
1673
1674 static int
1675 state2query(int rcm_state)
1676 {
1677 int query;
1678
1679 switch (rcm_state) {
1680 case RCM_STATE_OFFLINE_QUERY:
1681 case RCM_STATE_SUSPEND_QUERY:
1682 query = RI_QUERY_OK;
1683 break;
1684 case RCM_STATE_OFFLINE_QUERY_FAIL:
1685 case RCM_STATE_SUSPEND_QUERY_FAIL:
1686 query = RI_QUERY_FAIL;
1687 break;
1688 default:
1689 query = RI_QUERY_UNKNOWN;
1690 break;
1691 }
1692
1693 return (query);
1694 }
1695
1696 static void
1697 dev_list_append(ri_dev_t **head, ri_dev_t *dev)
1698 {
1699 ri_dev_t *tmp;
1700
1701 if ((tmp = *head) == NULL) {
1702 *head = dev;
1703 return;
1704 }
1705 while (tmp->next != NULL) {
1706 tmp = tmp->next;
1707 }
1708 tmp->next = dev;
1709 }
1710
1711 /*
1712 * The cpu list is ordered on cpuid since CMP cpuids will not necessarily
1713 * be discovered in sequence.
1714 */
1715 static void
1716 dev_list_cpu_insert(ri_dev_t **listp, ri_dev_t *dev, processorid_t newid)
1717 {
1718 ri_dev_t *tmp;
1719 int32_t cpuid;
1720
1721 while ((tmp = *listp) != NULL &&
1722 nvlist_lookup_int32(tmp->conf_props, RI_CPU_ID, &cpuid) == 0 &&
1723 cpuid < newid) {
1724 listp = &tmp->next;
1725 }
1726
1727 dev->next = tmp;
1728 *listp = dev;
1729 }
1730
1731 /*
1732 * Linear lookup. Should convert to hash tab.
1733 */
1734 static rcm_info_tuple_t *
1735 tuple_lookup(rcmd_t *rcm, const char *krsrc, const char *kinfo)
1736 {
1737 rcm_info_tuple_t *tuple = NULL;
1738 const char *rsrc, *info;
1739
1740 if ((rcm == NULL) || (krsrc == NULL) || (kinfo == NULL)) {
1741 return (NULL);
1742 }
1743
1744 while ((tuple = rcm_info_next(rcm->offline_query_info,
1745 tuple)) != NULL) {
1746 if ((rsrc = rcm_info_rsrc(tuple)) == NULL ||
1747 (info = rcm_info_info(tuple)) == NULL) {
1748 continue;
1749 }
1750
1751 if (strcmp(rsrc, krsrc) == 0 && strcmp(info, kinfo) == 0) {
1752 return (tuple);
1753 }
1754 }
1755 return (NULL);
1756 }
1757
1758 /*
1759 * Create and link attachment point handle.
1760 */
1761 static ri_ap_t *
1762 ri_ap_alloc(char *ap_id, ri_hdl_t *hdl)
1763 {
1764 ri_ap_t *ap, *tmp;
1765
1766 if ((ap = calloc(1, sizeof (*ap))) == NULL) {
1767 dprintf((stderr, "calloc: %s\n", strerror(errno)));
1768 return (NULL);
1769 }
1770
1771 if (nvlist_alloc(&ap->conf_props, NV_UNIQUE_NAME, 0) != 0 ||
1772 nvlist_add_string(ap->conf_props, RI_AP_REQ_ID, ap_id) != 0) {
1773 nvlist_free(ap->conf_props);
1774 free(ap);
1775 return (NULL);
1776 }
1777
1778 if ((tmp = hdl->aps) == NULL) {
1779 hdl->aps = ap;
1780 } else {
1781 while (tmp->next != NULL) {
1782 tmp = tmp->next;
1783 }
1784 tmp->next = ap;
1785 }
1786
1787 return (ap);
1788 }
1789
1790 static ri_dev_t *
1791 ri_dev_alloc(void)
1792 {
1793 ri_dev_t *dev;
1794
1795 if ((dev = calloc(1, sizeof (*dev))) == NULL ||
1796 nvlist_alloc(&dev->conf_props, NV_UNIQUE_NAME, 0) != 0) {
1797 s_free(dev);
1798 }
1799 return (dev);
1800 }
1801
1802 static ri_dev_t *
1803 io_dev_alloc(char *drv_inst)
1804 {
1805 ri_dev_t *io;
1806
1807 assert(drv_inst != NULL);
1808
1809 if ((io = ri_dev_alloc()) == NULL)
1810 return (NULL);
1811
1812 if (nvlist_add_string(io->conf_props, RI_IO_DRV_INST,
1813 drv_inst) != 0) {
1814 dprintf((stderr, "nvlist_add_string fail\n"));
1815 ri_dev_free(io);
1816 return (NULL);
1817 }
1818
1819 return (io);
1820 }
1821
1822 static ri_client_t *
1823 ri_client_alloc(char *rsrc, char *usage)
1824 {
1825 ri_client_t *client;
1826
1827 assert(rsrc != NULL && usage != NULL);
1828
1829 if ((client = calloc(1, sizeof (*client))) == NULL) {
1830 dprintf((stderr, "calloc: %s\n", strerror(errno)));
1831 return (NULL);
1832 }
1833
1834 if (nvlist_alloc(&client->usg_props, NV_UNIQUE_NAME, 0) != 0) {
1835 dprintf((stderr, "nvlist_alloc fail\n"));
1836 free(client);
1837 return (NULL);
1838 }
1839
1840 if (nvlist_add_string(client->usg_props, RI_CLIENT_RSRC, rsrc) != 0 ||
1841 nvlist_add_string(client->usg_props, RI_CLIENT_USAGE, usage) != 0) {
1842 dprintf((stderr, "nvlist_add_string fail\n"));
1843 ri_client_free(client);
1844 return (NULL);
1845 }
1846
1847 return (client);
1848 }
1849
1850 static void
1851 apd_tbl_free(apd_t apd_tbl[], int napds)
1852 {
1853 int i;
1854 apd_t *apd;
1855
1856 for (i = 0, apd = apd_tbl; i < napds; i++, apd++)
1857 s_free(apd->cfga_list_data);
1858
1859 free(apd_tbl);
1860 }
1861
1862 static char *
1863 pstate2str(int pi_state)
1864 {
1865 char *state;
1866
1867 switch (pi_state) {
1868 case P_OFFLINE:
1869 state = PS_OFFLINE;
1870 break;
1871 case P_ONLINE:
1872 state = PS_ONLINE;
1873 break;
1874 case P_FAULTED:
1875 state = PS_FAULTED;
1876 break;
1877 case P_POWEROFF:
1878 state = PS_POWEROFF;
1879 break;
1880 case P_NOINTR:
1881 state = PS_NOINTR;
1882 break;
1883 case P_SPARE:
1884 state = PS_SPARE;
1885 break;
1886 default:
1887 state = "unknown";
1888 break;
1889 }
1890
1891 return (state);
1892 }
1893
1894 #ifdef DEBUG
1895 static void
1896 dump_apd_tbl(FILE *fp, apd_t *apds, int n_apds)
1897 {
1898 int i, j;
1899 cfga_list_data_t *cfga_ldata;
1900
1901 for (i = 0; i < n_apds; i++, apds++) {
1902 dprintf((stderr, "apd_tbl[%d].nlist=%d\n", i, apds->nlist));
1903 for (j = 0, cfga_ldata = apds->cfga_list_data; j < apds->nlist;
1904 j++, cfga_ldata++) {
1905 dprintf((fp,
1906 "apd_tbl[%d].cfga_list_data[%d].ap_log_id=%s\n",
1907 i, j, cfga_ldata->ap_log_id));
1908 }
1909 }
1910 }
1911 #endif /* DEBUG */
1912
1913 /*
1914 * The lookup table is a simple array that is grown in chunks
1915 * to optimize memory allocation.
1916 * Indices are assigned to each array entry in-order so that
1917 * the original device tree ordering can be discerned at a later time.
1918 *
1919 * add_lookup_entry is called from the libdevinfo tree traversal callbacks:
1920 * 1) devinfo_node_walk - physical device path for each node in
1921 * the devinfo tree via di_walk_node(), lookup entry name is
1922 * /devices/[di_devfs_path]
1923 * 2) devinfo_minor_walk - physical device path plus minor name for
1924 * each minor associated with a node via di_walk_minor(), lookup entry
1925 * name is /devices/[di_devfs_path:di_minor_name]
1926 * 3) devinfo_devlink_walk - for each minor's /dev link from its /devices
1927 * path via di_devlink_walk(), lookup entry name is di_devlink_path()
1928 */
1929 static int
1930 add_lookup_entry(lookup_table_t *table, const char *name, di_node_t node)
1931 {
1932 size_t size;
1933 lookup_entry_t *new_table;
1934
1935
1936 /* Grow the lookup table by USAGE_ALLOC_SIZE slots if necessary */
1937 if (table->n_entries == table->n_slots) {
1938 size = (table->n_slots + USAGE_ALLOC_SIZE) *
1939 sizeof (lookup_entry_t);
1940 new_table = (lookup_entry_t *)realloc(table->table, size);
1941 if (new_table == NULL) {
1942 dprintf((stderr, "add_lookup_entry: alloc failed: %s\n",
1943 strerror(errno)));
1944 errno = ENOMEM;
1945 return (-1);
1946 }
1947 table->table = new_table;
1948 table->n_slots += USAGE_ALLOC_SIZE;
1949 }
1950
1951 dprintf((stderr, "add_lookup_entry[%d]:%s\n", table->n_entries, name));
1952
1953 /* Add this name to the next slot */
1954 if ((table->table[table->n_entries].name = strdup(name)) == NULL) {
1955 dprintf((stderr, "add_lookup_entry: strdup failed: %s\n",
1956 strerror(errno)));
1957 errno = ENOMEM;
1958 return (-1);
1959 }
1960 table->table[table->n_entries].index = table->n_entries;
1961 table->table[table->n_entries].node = node;
1962 table->table[table->n_entries].n_usage = 0;
1963 table->table[table->n_entries].usage = NULL;
1964 table->n_entries += 1;
1965
1966 return (0);
1967 }
1968
1969 /*
1970 * lookup table entry names are full pathname strings, all start with /
1971 */
1972 static int
1973 table_compare_names(const void *a, const void *b)
1974 {
1975 lookup_entry_t *entry1 = (lookup_entry_t *)a;
1976 lookup_entry_t *entry2 = (lookup_entry_t *)b;
1977
1978 return (strcmp(entry1->name, entry2->name));
1979 }
1980
1981
1982 /*
1983 * Compare two indices and return -1 for less, 1 for greater, 0 for equal
1984 */
1985 static int
1986 table_compare_indices(const void *a, const void *b)
1987 {
1988 lookup_entry_t *entry1 = (lookup_entry_t *)a;
1989 lookup_entry_t *entry2 = (lookup_entry_t *)b;
1990
1991 if (entry1->index < entry2->index)
1992 return (-1);
1993 if (entry1->index > entry2->index)
1994 return (1);
1995 return (0);
1996 }
1997
1998 /*
1999 * Given a RCM resource name, find the matching entry in the IO device table
2000 */
2001 static lookup_entry_t *
2002 lookup(lookup_table_t *table, const char *rcm_rsrc)
2003 {
2004 lookup_entry_t *entry;
2005 lookup_entry_t lookup_arg;
2006
2007 dprintf((stderr, "lookup:%s\n", rcm_rsrc));
2008 lookup_arg.name = (char *)rcm_rsrc;
2009 entry = bsearch(&lookup_arg, table->table, table->n_entries,
2010 sizeof (lookup_entry_t), table_compare_names);
2011
2012 #ifdef DEBUG
2013 if (entry != NULL) {
2014 dprintf((stderr, " found entry:%d\n", entry->index));
2015 }
2016 #endif /* DEBUG */
2017 return (entry);
2018 }
2019
2020 /*
2021 * Add RCM usage to the given device table entry.
2022 * Returns -1 on realloc failure.
2023 */
2024 static int
2025 add_usage(lookup_entry_t *entry, const char *rcm_rsrc, rcm_info_tuple_t *tuple)
2026 {
2027 size_t size;
2028 const char *info;
2029 usage_t *new_usage;
2030
2031 if ((entry == NULL) ||
2032 ((info = rcm_info_info(tuple)) == NULL))
2033 return (0);
2034
2035 if (rcm_ignore((char *)rcm_rsrc, (char *)info) == 0)
2036 return (0);
2037
2038 size = (entry->n_usage + 1) * sizeof (usage_t);
2039 new_usage = (usage_t *)realloc(entry->usage, size);
2040 if (new_usage == NULL) {
2041 dprintf((stderr, "add_usage: alloc failed: %s\n",
2042 strerror(errno)));
2043 return (-1);
2044 }
2045 dprintf((stderr, "add_usage: entry %d rsrc: %s info: %s\n",
2046 entry->index, rcm_rsrc, info));
2047
2048 entry->usage = new_usage;
2049 entry->usage[entry->n_usage].rsrc = rcm_rsrc;
2050 entry->usage[entry->n_usage].info = info;
2051 entry->n_usage += 1;
2052 return (0);
2053 }
2054
2055 static void
2056 empty_table(lookup_table_t *table)
2057 {
2058 int i;
2059
2060 if (table) {
2061 for (i = 0; i < table->n_entries; i++) {
2062 if (table->table[i].name)
2063 free(table->table[i].name);
2064 /*
2065 * Note: the strings pointed to from within
2066 * usage were freed already by rcm_free_info
2067 */
2068 if (table->table[i].usage)
2069 free(table->table[i].usage);
2070 }
2071 if (table->table)
2072 free(table->table);
2073 table->table = NULL;
2074 table->n_entries = 0;
2075 table->n_slots = 0;
2076 }
2077 }
unleashed repo fork