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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <ctype.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <unistd.h>
32 #include <macros.h>
33 #include <errno.h>
34 #include <kstat.h>
35 #include <sys/kmem.h>
36 #include <dlfcn.h>
37 #include <libdevinfo.h>
38 #include <librcm.h>
39 #include <libintl.h>
40 #define CFGA_PLUGIN_LIB
41 #include <config_admin.h>
42 #include <sys/sbd_ioctl.h>
43 #include "ap.h"
44
45 typedef int32_t cpuid_t;
46
47 typedef struct {
48 int valid;
49 cfga_stat_t ostate;
50 int ncap;
51 union {
52 long npages;
53 cpuid_t cpuid[SBD_MAX_CORES_PER_CMP];
54 } type;
55 } cap_info_t;
56
57 typedef struct {
58 int firstcm; /* first component to operate on */
59 int lastcm; /* last component to operate on */
60 void *lib;
61 char **rlist;
62 cap_info_t *capinfo;
63 int ncpus; /* # of CPUs in cpuids list */
64 cpuid_t *cpuids; /* List of cpuids */
65 int capcpus; /* # of CPUs - tracking capacity */
66 int cappages; /* # of memory pages - tracking capacity */
67 rcm_handle_t *hd;
68 rcm_info_t *rinfo;
69 rcm_info_tuple_t *infot;
70 int (*alloc_handle)(char *, uint_t, void *, rcm_handle_t **);
71 void (*free_handle)(rcm_handle_t *);
72 int (*get_info)(rcm_handle_t *, char *, uint_t, rcm_info_t **);
73 void (*free_info)(rcm_info_t *);
74 rcm_info_tuple_t *(*info_next)(rcm_info_t *, rcm_info_tuple_t *);
75 int (*info_state)(rcm_info_tuple_t *);
76 pid_t (*info_pid)(rcm_info_tuple_t *);
77 const char *(*info_error)(rcm_info_tuple_t *);
78 const char *(*info_info)(rcm_info_tuple_t *);
79 const char *(*info_rsrc)(rcm_info_tuple_t *);
80 int (*request_offline_list)(rcm_handle_t *, char **, uint_t,
81 rcm_info_t **);
82 int (*notify_online_list)(rcm_handle_t *, char **, uint_t,
83 rcm_info_t **);
84 int (*request_suspend)(rcm_handle_t *, char *, uint_t, timespec_t *,
85 rcm_info_t **);
86 int (*notify_resume)(rcm_handle_t *, char *, uint_t, rcm_info_t **);
87 int (*notify_remove_list)(rcm_handle_t *, char **, uint_t,
88 rcm_info_t **);
89 int (*request_capacity_change)(rcm_handle_t *, char *, uint_t,
90 nvlist_t *, rcm_info_t **);
91 int (*notify_capacity_change)(rcm_handle_t *, char *, uint_t,
92 nvlist_t *, rcm_info_t **);
93 } rcmd_t;
94
95 static char *
96 ap_rcm_ops[] = {
97 "rcm_alloc_handle",
98 "rcm_free_handle",
99 "rcm_get_info",
100 "rcm_free_info",
101 "rcm_info_next",
102 "rcm_info_state",
103 "rcm_info_pid",
104 "rcm_info_error",
105 "rcm_info_info",
106 "rcm_info_rsrc",
107 "rcm_request_offline_list",
108 "rcm_notify_online_list",
109 "rcm_request_suspend",
110 "rcm_notify_resume",
111 "rcm_notify_remove_list",
112 "rcm_request_capacity_change",
113 "rcm_notify_capacity_change",
114 NULL
115 };
116
117 #define ALLOC_HANDLE 0
118 #define FREE_HANDLE 1
119 #define GET_INFO 2
120 #define FREE_INFO 3
121 #define INFO_TUPLE_NEXT 4
122 #define INFO_TUPLE_STATE 5
123 #define INFO_TUPLE_ID 6
124 #define INFO_TUPLE_ERROR 7
125 #define INFO_TUPLE_INFO 8
126 #define INFO_TUPLE_RSRC 9
127 #define REQUEST_OFFLINE 10
128 #define NOTIFY_ONLINE 11
129 #define REQUEST_SUSPEND 12
130 #define NOTIFY_RESUME 13
131 #define NOTIFY_REMOVE 14
132 #define REQUEST_CAP_CHANGE 15
133 #define NOTIFY_CAP_CHANGE 16
134
135 /*
136 * There is no consumer for SUNW_OS. This is defined here
137 * for generic OS quiescence.
138 */
139 #define OS "SUNW_OS" /* XXX */
140
141 /* Max width of an RCM formatted message line */
142 #define RCM_MAX_FORMAT 80
143
144 #ifdef __sparcv9
145 #define RCMLIB "/lib/sparcv9/librcm.so";
146 #elif defined(__amd64)
147 #define RCMLIB "/lib/amd64/librcm.so";
148 #else
149 #define RCMLIB "/lib/librcm.so";
150 #endif
151
152 static cfga_err_t
153 ap_capinfo(apd_t *a, int firstcm, int lastcm, cap_info_t **capinfo)
154 {
155 int cm;
156 int ncm;
157 void *cap;
158 int *ncap;
159 cfga_stat_t *os;
160 cap_info_t *cinfo, *cp;
161
162 DBG("ap_capinfo(%p)\n", (void *)a);
163
164 if (capinfo == NULL) {
165 ap_err(a, ERR_PLUGIN, "null capinfo");
166 return (CFGA_LIB_ERROR);
167 }
168
169 /*
170 * Assume there are components with valid capacity
171 * information and allocate space for them. If there
172 * are none at the end, free the allocated space.
173 */
174 ncm = lastcm - firstcm + 1;
175
176 cinfo = (cap_info_t *)calloc(ncm, sizeof (cap_info_t));
177 if (cinfo == NULL) {
178 ap_err(a, ERR_NOMEM);
179 return (CFGA_LIB_ERROR);
180 }
181
182 *capinfo = NULL;
183 ncm = 0;
184 for (cp = cinfo, cm = firstcm; cm <= lastcm; cm++, cp++) {
185 os = &cp->ostate;
186 ncap = &cp->ncap;
187
188 switch (ap_cm_type(a, cm)) {
189 case AP_CPU:
190 case AP_CMP:
191 cap = (void *)(cp->type.cpuid);
192 break;
193 case AP_MEM:
194 cap = (void *)&(cp->type.npages);
195 break;
196 default:
197 continue;
198 }
199 /*
200 * Remember which components have valid
201 * capacity information.
202 */
203 if (ap_cm_capacity(a, cm, cap, ncap, os)) {
204 cp->valid = 1;
205 ncm++;
206 }
207 }
208
209 if (ncm == 0)
210 free(cinfo);
211 else
212 *capinfo = cinfo;
213
214 return (CFGA_OK);
215 }
216
217 static int
218 getsyscpuids(int *ncpuids, cpuid_t **cpuids)
219 {
220 int ncpu;
221 int maxncpu;
222 kstat_t *ksp;
223 kstat_ctl_t *kc = NULL;
224 cpuid_t *cp;
225
226 DBG("getsyscpuids\n");
227
228 if ((maxncpu = sysconf(_SC_NPROCESSORS_MAX)) == -1 ||
229 (kc = kstat_open()) == NULL ||
230 (cp = (cpuid_t *)calloc(maxncpu, sizeof (cpuid_t))) == NULL) {
231 /* if calloc failed, clean up kstats */
232 if (kc != NULL) {
233 (void) kstat_close(kc);
234 }
235 return (-1);
236 }
237
238 DBG("syscpuids: ");
239 for (ncpu = 0, ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
240 if (strcmp(ksp->ks_module, "cpu_info") == 0) {
241 cp[ncpu++] = ksp->ks_instance;
242 DBG("%d ", ksp->ks_instance);
243 }
244 }
245 DBG("\n");
246
247 (void) kstat_close(kc);
248 *cpuids = cp;
249 *ncpuids = ncpu;
250 return (0);
251 }
252
253 cfga_err_t
254 ap_rcm_init(apd_t *a)
255 {
256 int i;
257 char *err;
258 char *rcmlib;
259 void *sym;
260 void *lib;
261 char **op;
262 rcmd_t *rcm;
263 cfga_err_t rc;
264 struct stat buf;
265
266 DBG("ap_rcm_init(%p)\n", (void *)a);
267
268 /*
269 * If the initial command is status, or the RCM feature is not
270 * available, or the RCM interface has already been initialized,
271 * just return.
272 */
273
274 if ((a->statonly != 0) || (a->norcm != 0) ||
275 ((rcm = (rcmd_t *)a->rcm) != NULL)) {
276 return (CFGA_OK);
277 }
278
279 rcmlib = RCMLIB;
280 rc = CFGA_LIB_ERROR;
281
282 DBG("Looking for %s\n", rcmlib);
283 /*
284 * If the library is not present, there is nothing more
285 * to do. The RCM offline/suspend steps become no-ops
286 * in that case.
287 */
288 if (stat(rcmlib, &buf) == -1) {
289 if (errno == ENOENT) {
290 a->norcm++;
291 ap_msg(a, MSG_NORCM);
292 return (CFGA_OK);
293 } else {
294 ap_err(a, ERR_STAT, rcmlib);
295 return (rc);
296 }
297 }
298 DBG("%s found\n", rcmlib);
299
300 if ((a->rcm = calloc(1, sizeof (rcmd_t))) == NULL) {
301 ap_err(a, ERR_NOMEM);
302 return (rc);
303 }
304
305 rcm = (rcmd_t *)a->rcm;
306
307 if ((lib = dlopen(rcmlib, RTLD_NOW)) == NULL) {
308 if ((err = dlerror()) != NULL)
309 err = strdup(err);
310 ap_err(a, ERR_LIB_OPEN, rcmlib, err);
311 if (err != NULL)
312 free(err);
313 return (rc);
314 }
315
316 rcm->lib = lib;
317
318 for (i = 0, op = ap_rcm_ops; *op != NULL; op++, i++) {
319 if ((sym = dlsym(lib, *op)) == NULL) {
320 ap_err(a, ERR_LIB_SYM, rcmlib, *op);
321 return (rc);
322 }
323 switch (i) {
324 case ALLOC_HANDLE:
325 rcm->alloc_handle = (int(*)
326 (char *, uint_t, void *, rcm_handle_t **))sym;
327 break;
328 case FREE_HANDLE:
329 rcm->free_handle = (void (*)(rcm_handle_t *))sym;
330 break;
331 case GET_INFO:
332 rcm->get_info = (int (*)
333 (rcm_handle_t *, char *, uint_t, rcm_info_t **))sym;
334 break;
335 case FREE_INFO:
336 rcm->free_info = (void (*)(rcm_info_t *))sym;
337 break;
338 case INFO_TUPLE_NEXT:
339 rcm->info_next = (rcm_info_tuple_t *(*)
340 (rcm_info_t *, rcm_info_tuple_t *))sym;
341 break;
342 case INFO_TUPLE_STATE:
343 rcm->info_state = (int (*)(rcm_info_tuple_t *))sym;
344 break;
345 case INFO_TUPLE_ID:
346 rcm->info_pid = (pid_t (*)(rcm_info_tuple_t *))sym;
347 break;
348 case INFO_TUPLE_ERROR:
349 rcm->info_error = (const char *(*)
350 (rcm_info_tuple_t *))sym;
351 break;
352 case INFO_TUPLE_INFO:
353 rcm->info_info = (const char *(*)
354 (rcm_info_tuple_t *))sym;
355 break;
356 case INFO_TUPLE_RSRC:
357 rcm->info_rsrc = (const char *(*)
358 (rcm_info_tuple_t *))sym;
359 break;
360 case REQUEST_OFFLINE:
361 rcm->request_offline_list = (int (*)
362 (rcm_handle_t *, char **, uint_t,
363 rcm_info_t **))sym;
364 break;
365 case NOTIFY_ONLINE:
366 rcm->notify_online_list = (int (*)
367 (rcm_handle_t *, char **, uint_t,
368 rcm_info_t **))sym;
369 break;
370 case REQUEST_SUSPEND:
371 rcm->request_suspend = (int (*)
372 (rcm_handle_t *, char *, uint_t,
373 timespec_t *, rcm_info_t **))sym;
374 break;
375 case NOTIFY_RESUME:
376 rcm->notify_resume = (int (*)
377 (rcm_handle_t *, char *, uint_t,
378 rcm_info_t **))sym;
379 break;
380 case NOTIFY_REMOVE:
381 rcm->notify_remove_list = (int (*)
382 (rcm_handle_t *, char **, uint_t,
383 rcm_info_t **))sym;
384 break;
385 case REQUEST_CAP_CHANGE:
386 rcm->request_capacity_change = (int (*)
387 (rcm_handle_t *, char *, uint_t,
388 nvlist_t *, rcm_info_t **))sym;
389 break;
390 case NOTIFY_CAP_CHANGE:
391 rcm->notify_capacity_change = (int (*)
392 (rcm_handle_t *, char *, uint_t,
393 nvlist_t *, rcm_info_t **))sym;
394 break;
395 default:
396 break;
397 }
398 }
399
400 if (rcm->alloc_handle == NULL ||
401 (*rcm->alloc_handle)(NULL, RCM_NOPID, NULL, &rcm->hd)
402 != RCM_SUCCESS) {
403 ap_err(a, ERR_RCM_HANDLE);
404 return (CFGA_LIB_ERROR);
405 }
406
407 /*
408 * Offlining/onlining a board means offlining/onlining
409 * all components on the board. When operating on a
410 * single component no component sequence number is
411 * needed since the default is the current (target)
412 * component.
413 */
414 if (a->tgt == AP_BOARD) {
415 rcm->firstcm = 0;
416 rcm->lastcm = a->ncm - 1;
417 } else {
418 rcm->firstcm = CM_DFLT;
419 rcm->lastcm = CM_DFLT;
420 }
421
422 if (rcm->cpuids == NULL) {
423 int cm;
424 int ncpu;
425
426 /*
427 * Allocate space for the cpu capacity change info.
428 * Not every cpu may be relevant to the capacity
429 * request, but allocating for the maximum makes
430 * it easier, and the space is insignifcant.
431 */
432 for (ncpu = 0, cm = rcm->firstcm; cm <= rcm->lastcm; cm++) {
433
434 ap_target_t type = ap_cm_type(a, cm);
435
436 if ((type == AP_CPU) || (type == AP_CMP)) {
437 ncpu += ap_cm_ncap(a, cm);
438 }
439 }
440
441 rcm->ncpus = ncpu;
442 if ((rcm->cpuids = (cpuid_t *)calloc(ncpu, sizeof (cpuid_t)))
443 == NULL) {
444 ap_err(a, ERR_NOMEM);
445 return (CFGA_LIB_ERROR);
446 }
447 }
448
449 /*
450 * Remember initial capacity information.
451 * This information is based on the initial
452 * state of the ap_id, i.e. before any
453 * state change change operations were
454 * executed. We will later get the
455 * current capacity information in order
456 * to figure out exactly what has changed
457 * as the result of the executed command
458 * sequence.
459 */
460 rc = ap_capinfo(a, rcm->firstcm, rcm->lastcm, &rcm->capinfo);
461
462 rcm->capcpus = sysconf(_SC_NPROCESSORS_CONF);
463 rcm->cappages = sysconf(_SC_PHYS_PAGES);
464
465 return (rc);
466 }
467
468 void
469 ap_rcm_fini(apd_t *a)
470 {
471 rcmd_t *rcm;
472 char **rp;
473
474 DBG("ap_rcm_fini(%p)\n", (void *)a);
475
476 if ((rcm = (rcmd_t *)a->rcm) == NULL)
477 return;
478
479 if (rcm->hd)
480 (*rcm->free_handle)(rcm->hd);
481
482 (void) dlclose(rcm->lib);
483
484 /*
485 * Free all the names in the resource list, followed
486 * by the resource list itself.
487 */
488 if (rcm->rlist)
489 for (rp = rcm->rlist; *rp; rp++)
490 s_free(*rp);
491 s_free(rcm->rlist);
492 s_free(rcm->cpuids);
493 s_free(rcm->capinfo);
494 s_free(a->rcm);
495 }
496
497 static cfga_err_t
498 ap_rcm_rlist(apd_t *a, int firstcm, int lastcm, char ***rlist, int cmd)
499 {
500 int n;
501 int cm;
502 int ncap;
503 char *path;
504 char *cpuname;
505 char **rp;
506
507 DBG("ap_rcm_rlist(%p)\n", (void *)a);
508
509 /*
510 * Allocate space for the maximum number of components
511 * that can be affected by this operation.
512 */
513 for (ncap = 0, cm = firstcm; cm <= lastcm; cm++) {
514 ncap += ap_cm_ncap(a, cm);
515 }
516
517 DBG("ncap=%d\n", ncap);
518
519 if ((rp = (char **)calloc(ncap + 1, sizeof (char *))) == NULL) {
520 ap_err(a, ERR_NOMEM);
521 return (CFGA_LIB_ERROR);
522 }
523
524 n = 12; /* SUNW_cpu/cpuCCC */
525 /* <--- 12 ---> */
526 cpuname = "SUNW_cpu/cpuCCC";
527 /*
528 * Set the RCM resource name for each component:
529 *
530 * io: <device-path>
531 * cpu: SUNW_cpu/cpu<cpuid>
532 *
533 */
534 for (ncap = 0, cm = firstcm; cm <= lastcm; cm++) {
535 switch (ap_cm_type(a, cm)) {
536 case AP_CPU:
537 case AP_CMP: {
538 int i;
539 int len;
540 cap_info_t cap;
541 cfga_stat_t os;
542 cpuid_t *cpuid;
543 int *nc;
544 cap_info_t *prevcap;
545 rcmd_t *rcm;
546 int allow_op;
547 int capindex;
548
549 cpuid = cap.type.cpuid;
550 nc = &cap.ncap;
551
552 /*
553 * See if the request target is a single
554 * (default) component
555 */
556 capindex = (cm == CM_DFLT) ? 0 : cm;
557
558 /* Get the previous capacity info */
559 rcm = (rcmd_t *)a->rcm;
560 prevcap = rcm->capinfo;
561
562 if (!ap_cm_capacity(a, cm, cpuid, nc, &os)) {
563 break;
564 }
565
566 len = (strlen(cpuname) - n) + 1;
567
568 /*
569 * For CMD_RCM_OFFLINE and REMOVE, add the CPU to the
570 * list if it is currently configured. For
571 * CMD_RCM_ONLINE, do so only if the state has changed
572 * to CFGA_STAT_CONFIGURED.
573 */
574 allow_op = 0;
575 if ((cmd == CMD_RCM_OFFLINE) ||
576 (cmd == CMD_RCM_REMOVE)) {
577 if (os == CFGA_STAT_CONFIGURED)
578 allow_op = 1;
579 } else {
580 if ((os == CFGA_STAT_CONFIGURED) &&
581 ((prevcap == NULL) ||
582 (prevcap[capindex].ostate != os)))
583 allow_op = 1;
584 }
585
586 if (allow_op) {
587 for (i = 0; i < *nc; i++) {
588 if ((path = strdup(cpuname)) == NULL) {
589 ap_err(a, ERR_NOMEM);
590 return (CFGA_LIB_ERROR);
591 }
592 (void) snprintf(&path[n], len, "%d",
593 cpuid[i]);
594
595 DBG("rp[%d]=%s\n", ncap, path);
596 rp[ncap++] = path;
597 }
598 }
599 break;
600 }
601 case AP_IO:
602 if ((path = ap_cm_devpath(a, cm)) != NULL) {
603 DBG("rp[%d]=%s\n", ncap, path);
604 rp[ncap++] = path;
605 }
606 break;
607 case AP_MEM:
608 /*
609 * Nothing to do for AP_MEM since only capacity
610 * change notifications apply to SUNW_memory
611 */
612 default:
613 break;
614 }
615 }
616
617 rp[ncap] = NULL;
618 if (rlist)
619 *rlist = rp;
620 return (CFGA_OK);
621 }
622
623 /*
624 * Returns 1 if the cpu ID 'cpuid' is in the list of CPU IDs
625 * 'list' of length 'length'. Returns 0 otherwise.
626 */
627 static int
628 is_cpu_in_list(cpuid_t cpuid, cpuid_t *list, int length)
629 {
630 int i;
631
632 DBG("is_cpu_in_list\n");
633
634 if (list == NULL)
635 return (0);
636
637 for (i = 0; i < length; i++) {
638 if (list[i] == cpuid)
639 return (1);
640 }
641 return (0);
642 }
643
644 static int
645 ap_rcm_cap_cpu(apd_t *a, rcmd_t *rcm, rcm_handle_t *hd, uint_t flags,
646 rcm_info_t **rinfo, int cmd, int change)
647 {
648 int i;
649 int rv = RCM_FAILURE;
650 int ncpuids;
651 int oldncpuids;
652 int newncpuids;
653 char buf[32];
654 const char *fmt;
655 size_t size;
656 nvlist_t *nvl = NULL;
657 cpuid_t *cpuids = NULL;
658 cpuid_t *oldcpuids = NULL;
659 cpuid_t *newcpuids = NULL;
660
661 DBG("ap_rcm_cap_cpu(%p)\n", (void *)a);
662
663 /*
664 * Get the current number of configured cpus.
665 */
666 if (getsyscpuids(&ncpuids, &cpuids) == -1)
667 return (rv);
668 else if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
669 free(cpuids);
670 goto done;
671 }
672
673 if (change == 1)
674 fmt = "(%d cpu)";
675 else
676 fmt = "(%d cpus)";
677
678 size = sizeof (cpuid_t);
679
680 if (cmd == CMD_RCM_CAP_DEL) {
681 /*
682 * A delete request. rcm->cpuids represents the
683 * cpus that will be unconfigured. The current
684 * set of cpus, before the unconfigure operation,
685 * are the old CPUs. The new CPUs are those
686 * that would remain.
687 */
688 oldncpuids = ncpuids;
689 oldcpuids = cpuids;
690
691 /*
692 * Fill newcpuids with the CPU IDs in the cpuids array,
693 * but not in rcm->cpuids.
694 */
695 newcpuids = (cpuid_t *)calloc(ncpuids, size);
696 if (newcpuids == NULL)
697 goto done;
698
699 newncpuids = 0;
700 for (i = 0; i < ncpuids; i++) {
701 if (!is_cpu_in_list(cpuids[i], rcm->cpuids, change))
702 newcpuids[newncpuids++] = cpuids[i];
703 }
704 } else if (cmd == CMD_RCM_CAP_NOTIFY) {
705 /*
706 * An unconfigure capacity change notification. This
707 * notification is sent after a DR unconfigure, whether
708 * or not the DR was successful. rcm->cpuids represents
709 * the CPUs that have been unconfigured.
710 */
711
712 /* New CPU IDs are the CPUs configured right now. */
713 newncpuids = ncpuids;
714 newcpuids = cpuids;
715
716 /*
717 * Old CPU IDs are the CPUs configured right now
718 * in addition to those that have been unconfigured.
719 * We build the old CPU ID list by concatenating
720 * cpuids and rcm->cpuids.
721 */
722 oldcpuids = (cpuid_t *)calloc(ncpuids + change, size);
723 if (oldcpuids == NULL)
724 goto done;
725
726 oldncpuids = 0;
727 for (i = 0; i < ncpuids; i++) {
728 if (!is_cpu_in_list(cpuids[i], rcm->cpuids, change))
729 oldcpuids[oldncpuids++] = cpuids[i];
730 }
731 for (i = 0; i < change; i++)
732 oldcpuids[oldncpuids++] = rcm->cpuids[i];
733 } else {
734 DBG("ap_rcm_cap_cpu: CPU capacity, old = %d, new = %d \n",
735 rcm->capcpus, ncpuids);
736 if (rcm->capcpus == ncpuids) {
737 /* No real change in CPU capacity */
738 rv = RCM_SUCCESS;
739 goto done;
740 }
741
742 /*
743 * An add notification. rcm->cpuids represents the
744 * cpus that have been configured. The current
745 * set of cpus, after the configure operation,
746 * are the new CPU IDs.
747 */
748 newncpuids = ncpuids;
749 newcpuids = cpuids;
750
751 /*
752 * Fill oldcpuids with the CPU IDs in the cpuids array,
753 * but not in rcm->cpuids.
754 */
755 oldcpuids = (cpuid_t *)calloc(ncpuids, size);
756 if (oldcpuids == NULL)
757 goto done;
758
759 oldncpuids = 0;
760 for (i = 0; i < ncpuids; i++) {
761 if (!is_cpu_in_list(cpuids[i], rcm->cpuids, change))
762 oldcpuids[oldncpuids++] = cpuids[i];
763 }
764 }
765
766 DBG("oldcpuids: ");
767 for (i = 0; i < oldncpuids; i++)
768 DBG("%d ", oldcpuids[i]);
769 DBG("\n");
770 DBG("change : ");
771 for (i = 0; i < change; i++)
772 DBG("%d ", rcm->cpuids[i]);
773 DBG("\n");
774 DBG("newcpuids: ");
775 for (i = 0; i < newncpuids; i++)
776 DBG("%d ", newcpuids[i]);
777 DBG("\n");
778
779 if (nvlist_add_string(nvl, "state", "capacity") != 0 ||
780 nvlist_add_int32(nvl, "old_total", oldncpuids) != 0 ||
781 nvlist_add_int32(nvl, "new_total", newncpuids) != 0 ||
782 nvlist_add_int32_array(nvl, "old_cpu_list", oldcpuids,
783 oldncpuids) != 0 ||
784 nvlist_add_int32_array(nvl, "new_cpu_list", newcpuids,
785 newncpuids) != 0)
786 goto done;
787
788 (void) snprintf(buf, sizeof (buf), fmt, change);
789 ap_msg(a, MSG_ISSUE, cmd, buf);
790
791 if (cmd == CMD_RCM_CAP_DEL) {
792 rv = (*rcm->request_capacity_change)(hd, "SUNW_cpu",
793 flags, nvl, rinfo);
794 } else {
795 rv = (*rcm->notify_capacity_change)(hd, "SUNW_cpu",
796 flags & ~RCM_FORCE, nvl, rinfo);
797 }
798
799 done:
800 nvlist_free(nvl);
801 s_free(oldcpuids);
802 s_free(newcpuids);
803 return (rv);
804 }
805
806 static int
807 ap_rcm_cap_mem(apd_t *a, rcmd_t *rcm, rcm_handle_t *hd, uint_t flags,
808 rcm_info_t **rinfo, int cmd, long change)
809 {
810 int rv;
811 int pgsize;
812 long oldpages;
813 long newpages;
814 long currpages;
815 char buf[32];
816 nvlist_t *nvl;
817
818 DBG("ap_rcm_cap_mem(%p)\n", (void *)a);
819
820 /*
821 * Get the current amount of configured memory.
822 */
823 if ((pgsize = sysconf(_SC_PAGE_SIZE)) == -1 ||
824 (currpages = sysconf(_SC_PHYS_PAGES)) == -1 ||
825 nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) > 0)
826 return (RCM_FAILURE);
827
828 /*
829 * If this is a (delete) request, change represents
830 * the amount of capacity that will be deleted from the
831 * system. If this is an (add) notification, change
832 * represents the amount of capacity that has already
833 * been added to the system.
834 */
835 if (cmd == CMD_RCM_CAP_DEL) {
836 oldpages = currpages;
837 newpages = currpages - change;
838 } else if (cmd == CMD_RCM_CAP_NOTIFY) {
839 newpages = currpages;
840 oldpages = rcm->cappages;
841 } else {
842 if (rcm->cappages == currpages) {
843 /* No real change in memory capacity */
844 DBG("ap_rcm_cap_mem: no change in capacity.\n");
845 nvlist_free(nvl);
846 return (RCM_SUCCESS);
847 }
848
849 oldpages = currpages - change;
850 newpages = currpages;
851 }
852
853 DBG("ap_rcm_cap_mem: Memory capacity, old = %ld, new = %ld\n",
854 oldpages, newpages);
855
856 if (nvlist_add_string(nvl, "state", "capacity") != 0 ||
857 nvlist_add_int32(nvl, "page_size", pgsize) != 0 ||
858 nvlist_add_int32(nvl, "old_pages", oldpages) != 0 ||
859 nvlist_add_int32(nvl, "new_pages", newpages) != 0) {
860 nvlist_free(nvl);
861 return (RCM_FAILURE);
862 }
863
864 (void) snprintf(buf, sizeof (buf), "(%ld pages)", change);
865 ap_msg(a, MSG_ISSUE, cmd, buf);
866
867 if (cmd == CMD_RCM_CAP_DEL) {
868 rv = (*rcm->request_capacity_change)(hd, "SUNW_memory",
869 flags, nvl, rinfo);
870 } else {
871 rv = (*rcm->notify_capacity_change)(hd, "SUNW_memory",
872 flags & ~RCM_FORCE, nvl, rinfo);
873 }
874
875 nvlist_free(nvl);
876
877 return (rv);
878 }
879
880 static cfga_err_t
881 ap_rcm_request_cap(apd_t *a, rcmd_t *rcm, rcm_handle_t *hd,
882 int *rv, uint_t flags, rcm_info_t **rinfo)
883 {
884 int cm;
885 int ncpus;
886 long npages;
887 cap_info_t *capinfo;
888 ap_target_t type;
889
890 DBG("ap_rcm_request_cap(%p)\n", (void *)a);
891
892 if ((capinfo = rcm->capinfo) == NULL) {
893 ap_err(a, ERR_PLUGIN, "null capinfo");
894 return (CFGA_LIB_ERROR);
895 }
896
897 ncpus = npages = 0;
898
899 for (cm = rcm->firstcm; cm <= rcm->lastcm; cm++) {
900 int i, j;
901
902 /*
903 * See if the request target is a single
904 * (default) component
905 */
906 i = (cm == CM_DFLT) ? 0 : cm;
907
908 /*
909 * We are interested only in those components
910 * in the configured state since they represent
911 * available capacity.
912 */
913 type = ap_cm_type(a, cm);
914 if (capinfo[i].valid == 0 ||
915 capinfo[i].ostate != CFGA_STAT_CONFIGURED)
916 continue;
917 else if ((type == AP_CPU) || (type == AP_CMP)) {
918 for (j = 0; j < capinfo[i].ncap; j++) {
919 rcm->cpuids[ncpus++] = capinfo[i].type.cpuid[j];
920 }
921 } else if (type == AP_MEM)
922 npages += capinfo[i].type.npages;
923 }
924
925 if (ncpus && ((*rv = ap_rcm_cap_cpu(a, rcm, hd, flags, rinfo,
926 CMD_RCM_CAP_DEL, ncpus)) != RCM_SUCCESS)) {
927 return (CFGA_LIB_ERROR);
928 }
929 if (npages && ((*rv = ap_rcm_cap_mem(a, rcm, hd, flags, rinfo,
930 CMD_RCM_CAP_DEL, npages)) != RCM_SUCCESS)) {
931 return (CFGA_LIB_ERROR);
932 }
933
934 return (CFGA_OK);
935 }
936
937 static cfga_err_t
938 ap_rcm_add_cap(apd_t *a, rcmd_t *rcm, rcm_handle_t *hd,
939 int *rv, uint_t flags, rcm_info_t **rinfo)
940 {
941 int cm;
942 int ncpus;
943 long npages;
944 cap_info_t *capinfo, *prevcapinfo;
945 cfga_err_t rc;
946
947 DBG("ap_rcm_add_cap(%p)\n", (void *)a);
948
949 /* Get the new capacity info to figure out what has changed */
950 if ((rc = ap_capinfo(a, rcm->firstcm, rcm->lastcm, &capinfo)) !=
951 CFGA_OK)
952 return (rc);
953
954 if (capinfo == NULL) {
955 DBG("no pertinent capacity info\n");
956 return (CFGA_OK);
957 }
958
959 ncpus = npages = 0;
960 prevcapinfo = rcm->capinfo;
961
962 for (cm = rcm->firstcm; cm <= rcm->lastcm; cm++) {
963 int i, j;
964 cfga_stat_t os, prevos;
965 int prevvalidity;
966 ap_target_t type;
967
968 /*
969 * See if the request target is a single
970 * (default) component
971 */
972 i = cm == CM_DFLT ? 0 : cm;
973
974 os = capinfo[i].ostate;
975 if (prevcapinfo == NULL) {
976 prevos = CFGA_STAT_EMPTY;
977 prevvalidity = 1;
978 } else {
979 prevos = prevcapinfo[i].ostate;
980 prevvalidity = prevcapinfo[i].valid;
981 }
982
983 type = ap_cm_type(a, cm);
984
985 DBG("cm=%d valid=%d type=%d, prevos=%d os=%d\n",
986 cm, prevvalidity, type, prevos, os);
987
988 /*
989 * We are interested only in those components
990 * whose states have changed to configured as
991 * the result of the current cfgadm request.
992 */
993 if (prevvalidity == 0 || os != CFGA_STAT_CONFIGURED) {
994 capinfo[i].valid = 0;
995 continue;
996 } else if (prevos != CFGA_STAT_CONFIGURED) {
997 /*
998 * The occupant state is configured, and
999 * the previous occupant state was not.
1000 */
1001 if ((type == AP_CPU) || (type == AP_CMP)) {
1002 for (j = 0; j < capinfo[i].ncap; j++) {
1003 rcm->cpuids[ncpus++] =
1004 capinfo[i].type.cpuid[j];
1005 }
1006 } else if (type == AP_MEM)
1007 npages += capinfo[i].type.npages;
1008 }
1009 }
1010 free(capinfo);
1011
1012 if (ncpus && ((*rv = ap_rcm_cap_cpu(a, rcm, hd, flags, rinfo,
1013 CMD_RCM_CAP_ADD, ncpus)) != RCM_SUCCESS)) {
1014 return (CFGA_LIB_ERROR);
1015 }
1016 if (npages && ((*rv = ap_rcm_cap_mem(a, rcm, hd, flags, rinfo,
1017 CMD_RCM_CAP_ADD, npages)) != RCM_SUCCESS)) {
1018 return (CFGA_LIB_ERROR);
1019 }
1020
1021 return (CFGA_OK);
1022 }
1023
1024 /*
1025 * ap_rcm_notify_cap:
1026 *
1027 * This routine handles the CMD_RCM_CAP_NOTIFY command. It
1028 * is called after a successful/failed DR unconfigure
1029 * operation. It filters out components that have changed
1030 * and passes this information on to ap_rcm_cap_{cpu,mem}.
1031 *
1032 * ap_rcm_cap_{cpu,mem} will still be called if all the
1033 * components have not changed and at least one {cpu,mem}
1034 * component was originally configured.
1035 */
1036 static cfga_err_t
1037 ap_rcm_notify_cap(apd_t *a, rcmd_t *rcm, rcm_handle_t *hd,
1038 int *rv, uint_t flags, rcm_info_t **rinfo)
1039 {
1040 cfga_err_t rc;
1041 cap_info_t *capinfo;
1042 cap_info_t *prevcapinfo;
1043 int cm;
1044 long npages = 0;
1045 int ncpus = 0;
1046 int prev_mem = 0; /* # of prev. configured mem components */
1047 int prev_cpus = 0; /* # of prev. configured CPUs */
1048
1049 DBG("ap_rcm_notify_cap(%p)\n", (void *)a);
1050
1051 /* Get the new capacity info to figure out what has changed */
1052 if ((rc = ap_capinfo(a, rcm->firstcm, rcm->lastcm, &capinfo)) !=
1053 CFGA_OK)
1054 return (rc);
1055
1056 if (capinfo == NULL) {
1057 DBG("no pertinent capacity info\n");
1058 return (CFGA_OK);
1059 }
1060
1061 /* The original capacity info */
1062 prevcapinfo = rcm->capinfo;
1063
1064 /*
1065 * Cycle through all components that we are operating
1066 * on. Record which components' occupant states have
1067 * changed.
1068 */
1069 for (cm = rcm->firstcm; cm <= rcm->lastcm; cm++) {
1070 int i;
1071 cfga_stat_t prevos, os;
1072 ap_target_t type;
1073 int prev_conf = 0;
1074 int now_conf = 0;
1075
1076 /*
1077 * See if the request target is a single
1078 * (default) component
1079 */
1080 i = cm == CM_DFLT ? 0 : cm;
1081
1082 os = capinfo[i].ostate;
1083
1084 if (prevcapinfo == NULL) {
1085 prevos = CFGA_STAT_EMPTY;
1086 } else {
1087 prevos = prevcapinfo[i].ostate;
1088 if (prevcapinfo[i].valid == 0) {
1089 DBG("ap_rcm_notify_cap: skipping component "
1090 "due to prevvalidity == 0\n");
1091 continue;
1092 }
1093 }
1094
1095 type = ap_cm_type(a, cm);
1096
1097 prev_conf = (prevos == CFGA_STAT_CONFIGURED);
1098 now_conf = (os == CFGA_STAT_CONFIGURED);
1099
1100 /*
1101 * Build up rcm->cpuids with the IDs of CPUs that
1102 * have been removed. Record the number of removed
1103 * CPUs and pages.
1104 */
1105 if (type == AP_CPU || type == AP_CMP) {
1106 if (prev_conf)
1107 prev_cpus++;
1108 if (prev_conf && !now_conf) {
1109 int j;
1110 for (j = 0; j < capinfo[i].ncap; j++) {
1111 rcm->cpuids[ncpus++] =
1112 capinfo[i].type.cpuid[j];
1113 }
1114 }
1115 } else if (type == AP_MEM) {
1116 if (prev_conf)
1117 prev_mem++;
1118 if (prev_conf && !now_conf)
1119 npages += capinfo[i].type.npages;
1120 }
1121 }
1122 free(capinfo);
1123
1124 /*
1125 * If any CPU or memory components were operated on,
1126 * successfully or not, the rcm_notify_capacity_change()
1127 * routine must be called.
1128 */
1129
1130 if (prev_cpus) {
1131 *rv = ap_rcm_cap_cpu(a, rcm, hd, flags, rinfo,
1132 CMD_RCM_CAP_NOTIFY, ncpus);
1133
1134 if (*rv != RCM_SUCCESS)
1135 return (CFGA_LIB_ERROR);
1136 }
1137
1138 if (prev_mem) {
1139 *rv = ap_rcm_cap_mem(a, rcm, hd, flags, rinfo,
1140 CMD_RCM_CAP_NOTIFY, npages);
1141
1142 if (*rv != RCM_SUCCESS)
1143 return (CFGA_LIB_ERROR);
1144 }
1145
1146 return (CFGA_OK);
1147 }
1148
1149 cfga_err_t
1150 ap_rcm_ctl(apd_t *a, int cmd)
1151 {
1152 int i;
1153 int rv;
1154 int noop;
1155 int ncpus;
1156 int cm;
1157 uint_t flags;
1158 char *rsrc;
1159 char **rlist;
1160 rcmd_t *rcm;
1161 rcm_info_t *rinfo;
1162 rcm_handle_t *hd;
1163 cfga_err_t rc;
1164 cpuid_t *growcpuids;
1165
1166 DBG("ap_rcm_ctl(%p)\n", (void *)a);
1167
1168 if ((rcm = (rcmd_t *)a->rcm) == NULL) {
1169 ap_msg(a, MSG_SKIP, cmd, a->target);
1170 return (CFGA_OK);
1171 }
1172
1173 hd = rcm->hd;
1174 rv = RCM_SUCCESS;
1175 rc = CFGA_OK;
1176 if (ap_getopt(a, OPT_FORCE))
1177 flags = RCM_FORCE;
1178 else
1179 flags = 0;
1180 rinfo = NULL;
1181 rlist = NULL;
1182 rsrc = NULL;
1183 noop = 0;
1184
1185 switch (cmd) {
1186 case CMD_RCM_CAP_DEL:
1187 if (rcm->capinfo == NULL)
1188 noop++;
1189 else
1190 rc = ap_rcm_request_cap(a, rcm, hd, &rv, flags, &rinfo);
1191 break;
1192 case CMD_RCM_CAP_ADD:
1193 rc = ap_rcm_add_cap(a, rcm, hd, &rv, flags, &rinfo);
1194 break;
1195 case CMD_RCM_CAP_NOTIFY:
1196 rc = ap_rcm_notify_cap(a, rcm, hd, &rv, flags, &rinfo);
1197 break;
1198 case CMD_RCM_ONLINE:
1199 /* Refresh changed component states */
1200 if ((rc = ap_stat(a, 1)) != CFGA_OK) {
1201 noop++;
1202 break;
1203 }
1204
1205 if (a->tgt == AP_BOARD) {
1206 rcm->firstcm = 0;
1207 rcm->lastcm = a->ncm - 1;
1208
1209 /* Check if we need to grow our cpuids list */
1210 for (ncpus = 0, cm = rcm->firstcm; cm <= rcm->lastcm;
1211 cm++) {
1212 ap_target_t type = ap_cm_type(a, cm);
1213 if ((type == AP_CPU) || (type == AP_CMP))
1214 ncpus += ap_cm_ncap(a, cm);
1215 }
1216
1217 if (rcm->ncpus < ncpus) {
1218 if ((growcpuids =
1219 (cpuid_t *)realloc(rcm->cpuids,
1220 (ncpus * sizeof (cpuid_t)))) == NULL) {
1221 ap_err(a, ERR_NOMEM);
1222 return (CFGA_LIB_ERROR);
1223 }
1224 rcm->ncpus = ncpus;
1225 rcm->cpuids = growcpuids;
1226 }
1227
1228 } else {
1229 rcm->firstcm = CM_DFLT;
1230 rcm->lastcm = CM_DFLT;
1231 }
1232
1233 /*FALLTHROUGH*/
1234
1235 case CMD_RCM_OFFLINE:
1236 case CMD_RCM_REMOVE: {
1237 uint_t nrsrc;
1238
1239 if (cmd == CMD_RCM_REMOVE) {
1240 /*
1241 * An unconfigure has just taken place, so
1242 * refresh the changed component states.
1243 */
1244 if ((rc = ap_stat(a, 1)) != CFGA_OK) {
1245 noop++;
1246 break;
1247 }
1248 }
1249
1250 /* Check if this is an empty board, i.e. no components */
1251 if (a->ncm == 0) {
1252 noop++;
1253 break;
1254 }
1255
1256 if ((rlist = rcm->rlist) == NULL) {
1257 rc = ap_rcm_rlist(a, rcm->firstcm, rcm->lastcm, &rlist,
1258 cmd);
1259 if ((rc == CFGA_OK) && (rlist != NULL) &&
1260 (rlist[0] != NULL)) {
1261 rcm->rlist = rlist;
1262 } else {
1263 /* Do not pass up empty resource list to RCM */
1264 noop++;
1265 break;
1266 }
1267 }
1268 for (nrsrc = 0; rlist[nrsrc] != NULL; nrsrc++)
1269 ap_msg(a, MSG_ISSUE, cmd, rlist[nrsrc]);
1270 if (cmd == CMD_RCM_OFFLINE)
1271 rv = (*rcm->request_offline_list)(hd, rlist, flags,
1272 &rinfo);
1273 else if (cmd == CMD_RCM_ONLINE)
1274 rv = (*rcm->notify_online_list)(hd, rlist,
1275 flags & ~RCM_FORCE, &rinfo);
1276 else
1277 rv = (*rcm->notify_remove_list)(hd, rlist,
1278 flags & ~RCM_FORCE, &rinfo);
1279 break;
1280 }
1281 case CMD_RCM_SUSPEND: {
1282 timespec_t t;
1283 t.tv_sec = (time_t)0;
1284 t.tv_nsec = (long)0;
1285 rsrc = OS;
1286 ap_msg(a, MSG_ISSUE, cmd, rsrc);
1287 rv = (*rcm->request_suspend)(hd, rsrc, flags, &t, &rinfo);
1288 break;
1289 }
1290 case CMD_RCM_RESUME:
1291 rsrc = OS;
1292 ap_msg(a, MSG_ISSUE, cmd, rsrc);
1293 rv = (*rcm->notify_resume)(hd, rsrc, 0, &rinfo);
1294 break;
1295 default:
1296 ap_err(a, ERR_CMD_INVAL, cmd);
1297 return (CFGA_INVAL);
1298 }
1299
1300 if (rv != RCM_SUCCESS) {
1301 rcm->rinfo = rinfo;
1302 rcm->infot = NULL;
1303 ap_err(a, ERR_RCM_CMD, cmd);
1304 (*rcm->free_info)(rinfo);
1305 if (rc == CFGA_OK)
1306 rc = CFGA_LIB_ERROR; /* make sure error is set */
1307 }
1308 if ((rc == CFGA_OK) && (noop == 0)) {
1309 if (rlist)
1310 for (i = 0; rlist[i]; i++)
1311 ap_msg(a, MSG_DONE, cmd, rlist[i]);
1312 else if (rsrc)
1313 ap_msg(a, MSG_DONE, cmd, rsrc);
1314 else
1315 ap_msg(a, MSG_DONE, cmd, a->target);
1316 }
1317
1318 return (rc);
1319 }
1320
1321 /*
1322 * ap_rcm_info
1323 *
1324 * Takes an ap_id and a character pointer, and formats
1325 * the rcm_info_t data in the form of a table to the given character pointer.
1326 * Code duplicated from the scsi plugin.
1327 * Note: This function will go away when a generic librcm callback is
1328 * implemented to format RCM messages for plugins.
1329 */
1330 int
1331 ap_rcm_info(apd_t *a, char **msg)
1332 {
1333 rcmd_t *rcm;
1334 rcm_info_t *rinfo;
1335 int i;
1336 size_t w;
1337 size_t width = 0;
1338 size_t w_rsrc = 0;
1339 size_t w_info = 0;
1340 size_t msg_size = 0;
1341 uint_t tuples = 0;
1342 rcm_info_tuple_t *tuple = NULL;
1343 char *rsrc;
1344 char *info;
1345 char *newmsg;
1346 static char format[RCM_MAX_FORMAT];
1347 const char *infostr;
1348
1349
1350 DBG("ap_rcm_info(%p)\n", (void *)a);
1351
1352 /* Protect against invalid arguments */
1353 if ((a == NULL) || ((rcm = (rcmd_t *)a->rcm) == NULL) ||
1354 ((rinfo = rcm->rinfo) == NULL) || (msg == NULL)) {
1355 return (-1);
1356 }
1357
1358 /* Set localized table header strings */
1359 rsrc = dgettext(TEXT_DOMAIN, "Resource");
1360 info = dgettext(TEXT_DOMAIN, "Information");
1361
1362 /* A first pass, to size up the RCM information */
1363 while (tuple = (*rcm->info_next)(rinfo, tuple)) {
1364 if ((infostr = (*rcm->info_info)(tuple)) != NULL) {
1365 tuples++;
1366 if ((w = strlen((*rcm->info_rsrc)(tuple))) > w_rsrc)
1367 w_rsrc = w;
1368 if ((w = strlen(infostr)) > w_info)
1369 w_info = w;
1370 }
1371 }
1372
1373 /* If nothing was sized up above, stop early */
1374 if (tuples == 0)
1375 return (0);
1376
1377 /* Adjust column widths for column headings */
1378 if ((w = strlen(rsrc)) > w_rsrc)
1379 w_rsrc = w;
1380 else if ((w_rsrc - w) % 2)
1381 w_rsrc++;
1382 if ((w = strlen(info)) > w_info)
1383 w_info = w;
1384 else if ((w_info - w) % 2)
1385 w_info++;
1386
1387 /*
1388 * Compute the total line width of each line,
1389 * accounting for intercolumn spacing.
1390 */
1391 width = w_info + w_rsrc + 4;
1392
1393 /* Allocate space for the table */
1394 msg_size = (2 + tuples) * (width + 1) + 2;
1395 if (*msg == NULL) {
1396 /* zero fill for the strcat() call below */
1397 *msg = calloc(msg_size, sizeof (char));
1398 if (*msg == NULL)
1399 return (-1);
1400 } else {
1401 newmsg = realloc(*msg, strlen(*msg) + msg_size);
1402 if (newmsg == NULL)
1403 return (-1);
1404 else
1405 *msg = newmsg;
1406 }
1407
1408 /* Place a table header into the string */
1409
1410 /* The resource header */
1411 (void) strcat(*msg, "\n");
1412 w = strlen(rsrc);
1413 for (i = 0; i < ((w_rsrc - w) / 2); i++)
1414 (void) strcat(*msg, " ");
1415 (void) strcat(*msg, rsrc);
1416 for (i = 0; i < ((w_rsrc - w) / 2); i++)
1417 (void) strcat(*msg, " ");
1418
1419 /* The information header */
1420 (void) strcat(*msg, " ");
1421 w = strlen(info);
1422 for (i = 0; i < ((w_info - w) / 2); i++)
1423 (void) strcat(*msg, " ");
1424 (void) strcat(*msg, info);
1425 for (i = 0; i < ((w_info - w) / 2); i++)
1426 (void) strcat(*msg, " ");
1427
1428 /* Underline the headers */
1429 (void) strcat(*msg, "\n");
1430 for (i = 0; i < w_rsrc; i++)
1431 (void) strcat(*msg, "-");
1432 (void) strcat(*msg, " ");
1433 for (i = 0; i < w_info; i++)
1434 (void) strcat(*msg, "-");
1435
1436 /* Construct the format string */
1437 (void) snprintf(format, RCM_MAX_FORMAT, "%%-%ds %%-%ds",
1438 (int)w_rsrc, (int)w_info);
1439
1440 /* Add the tuples to the table string */
1441 tuple = NULL;
1442 while ((tuple = (*rcm->info_next)(rinfo, tuple)) != NULL) {
1443 if ((infostr = (*rcm->info_info)(tuple)) != NULL) {
1444 (void) strcat(*msg, "\n");
1445 (void) sprintf(&((*msg)[strlen(*msg)]), format,
1446 (*rcm->info_rsrc)(tuple), infostr);
1447 }
1448 }
1449
1450 DBG("ap_rcm_info(%p) success\n", (void *)a);
1451 return (0);
1452 }