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 2010 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 <string.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32 #include <libdevinfo.h>
33 #include <errno.h>
34 #include <libintl.h>
35 #define CFGA_PLUGIN_LIB
36 #include <config_admin.h>
37 #include "ap.h"
38 #include <sys/obpdefs.h>
39 #include <sys/processor.h>
40 #include <sys/stat.h>
41 #include <sys/sbd_ioctl.h>
42 #include <sys/int_fmtio.h>
43
44 static cfga_err_t
ap_getncm(apd_t * a,sbd_comp_type_t type,int * ncm)45 ap_getncm(apd_t *a, sbd_comp_type_t type, int *ncm)
46 {
47 sbd_ioctl_arg_t *ctl;
48 sbd_getncm_cmd_t *cp;
49
50 if (a->fd == -1 || a->ctl == NULL)
51 return (CFGA_LIB_ERROR);
52
53 ctl = (sbd_ioctl_arg_t *)a->ctl;
54 ctl->ic_type = type;
55 ctl->ic_name[0] = '\0';
56 ctl->ic_unit = 0;
57 ctl->i_len = 0;
58 ctl->i_opts = NULL;
59
60 DBG("ioctl(%d SBD_CMD_GETNCM, 0x%p)\n", a->fd, (void *)ctl);
61
62 if (ioctl(a->fd, SBD_CMD_GETNCM, ctl) == -1) {
63 ap_err(a, ERR_CMD_FAIL, CMD_GETNCM);
64 return (CFGA_ERROR);
65 }
66
67 cp = &ctl->i_cmd.cmd_getncm;
68
69 DBG("ncm(%d)=%d\n", type, cp->g_ncm);
70
71 if (ncm)
72 *ncm = cp->g_ncm;
73
74 return (CFGA_OK);
75 }
76
77 cfga_err_t
ap_stat(apd_t * a,int all)78 ap_stat(apd_t *a, int all)
79 {
80 int fd;
81 int ncm;
82 int select;
83 int stsize;
84 int oflag;
85 sbd_stat_cmd_t *sc;
86 sbd_ioctl_arg_t *ctl;
87 cfga_err_t rc;
88 sbd_stat_t *new_stat;
89
90 rc = CFGA_LIB_ERROR;
91
92 DBG("ap_stat(%s)\n", a->path);
93
94 /* Open the file descriptor if not already open */
95 if (a->fd == -1) {
96 DBG("open(%s)\n", a->path);
97 if (a->statonly != 0)
98 oflag = O_RDONLY;
99 else
100 oflag = O_RDWR;
101 if ((fd = open(a->path, oflag, 0)) == -1) {
102 ap_err(a, ERR_AP_INVAL);
103 return (rc);
104 }
105 a->fd = fd;
106 } else {
107 fd = a->fd;
108 }
109
110 if (a->ctl == NULL && (a->ctl = calloc(1, sizeof (*ctl))) == NULL) {
111 ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
112 return (rc);
113 }
114
115 if (a->tgt == AP_BOARD) {
116 /*
117 * The status target is the board. If we need to
118 * return component data (to support the -a option),
119 * get the number of components on the board.
120 */
121 select = 0;
122 if (all) {
123 cfga_err_t r;
124 r = ap_getncm(a, SBD_COMP_NONE, &ncm);
125 if (r != CFGA_OK) {
126 return (r);
127 }
128 } else {
129 ncm = 0;
130 }
131 } else {
132 select = 1;
133 ncm = 1;
134 }
135
136 DBG("ncm=%d\n", ncm);
137
138 a->ncm = ncm;
139
140 /*
141 * The status structure contains space for one component;
142 * add the space for the other components if necessary.
143 */
144 stsize = sizeof (sbd_stat_t);
145 if (ncm > 1)
146 stsize += ((ncm - 1) * sizeof (sbd_dev_stat_t));
147
148 if ((new_stat = realloc(a->stat, stsize)) == NULL) {
149 ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
150 return (rc);
151 }
152
153 a->stat = new_stat;
154
155
156 ctl = (sbd_ioctl_arg_t *)a->ctl;
157 ctl->i_len = 0;
158 ctl->i_opts = NULL;
159 ctl->ic_type = SBD_COMP_NONE;
160 if (all)
161 ctl->i_flags |= SBD_FLAG_ALLCMP;
162 sc = &ctl->i_cmd.cmd_stat;
163 sc->s_statp = (caddr_t)a->stat;
164 sc->s_nbytes = stsize;
165
166 if (select) {
167 /*
168 * The target is a specific component. Pass its
169 * name and unit number to the driver. Set its
170 * type to UNKNOWN since the plugin does not know
171 * the type of the component specified by the user.
172 */
173 ctl->ic_type = SBD_COMP_UNKNOWN;
174 ctl->ic_unit = a->cnum;
175 (void) strcpy(ctl->ic_name, a->cname);
176 }
177
178 DBG("ioctl(%d SBD_CMD_STATUS, sc=0x%p sz=%d flags=%d",
179 fd, (void *)sc->s_statp, sc->s_nbytes, ctl->i_flags);
180 if (select)
181 DBG(" cname=<%s> cnum=%d", a->cname, a->cnum);
182 DBG(")\n");
183
184 if (ioctl(fd, SBD_CMD_STATUS, ctl) == -1) {
185 ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
186 rc = CFGA_ERROR;
187 } else
188 rc = CFGA_OK;
189
190 DBG("ap_stat()=%d\n", rc);
191
192 return (rc);
193 }
194
195 /*
196 * Convert a component to a target type.
197 */
198 static ap_target_t
ap_cm_tgt(sbd_comp_type_t type)199 ap_cm_tgt(sbd_comp_type_t type)
200 {
201 ap_target_t c;
202
203 switch (type) {
204 case SBD_COMP_CPU:
205 c = AP_CPU;
206 break;
207 case SBD_COMP_MEM:
208 c = AP_MEM;
209 break;
210 case SBD_COMP_IO:
211 c = AP_IO;
212 break;
213 case SBD_COMP_CMP:
214 c = AP_CMP;
215 break;
216 default:
217 c = AP_NONE;
218 break;
219 }
220
221 return (c);
222 }
223
224 cfga_err_t
apd_init(apd_t * a,int all)225 apd_init(apd_t *a, int all)
226 {
227 int i;
228 char *cn, *dn;
229 sbd_stat_t *st;
230 sbd_dev_stat_t *dst;
231 cfga_err_t rc;
232
233 /*
234 * Ideally, for board operations (other than status) it is not
235 * necessary to issue the STATUS ioctl. The call however allows a
236 * final sanity check to ensure that the board number returned
237 * by the driver matches the plugin's notion of the board number
238 * as extracted from the ap_id. If this check is not desirable,
239 * we can change the code to issue the status call only when
240 * necessary. Note that for component operations, we need to do
241 * the STATUS in order to figure out the component type and
242 * validate the command/options accordingly. XXX
243 */
244 if ((rc = ap_stat(a, all)) != CFGA_OK) {
245 ap_err(a, ERR_AP_INVAL);
246 return (rc);
247 }
248
249 st = (sbd_stat_t *)a->stat;
250
251 /*
252 * Set the component count to the returned stat count.
253 */
254 if (a->ncm > st->s_nstat) {
255
256 DBG("ncm=%d nstat=%d (truncated)\n", a->ncm, st->s_nstat);
257
258 a->ncm = st->s_nstat;
259 }
260
261 if (a->tgt == AP_BOARD) {
262
263 DBG("tgt=%d\n", a->tgt);
264
265 /*
266 * Initialize the RCM module here so that it can record
267 * the initial state of the capacity information.
268 */
269 rc = ap_rcm_init(a);
270
271 return (rc);
272 }
273
274 a->tgt = AP_NONE;
275 cn = a->cname;
276
277 DBG("cname=<%s> cunit=<%d>\n", a->cname, a->cnum);
278
279 for (dst = st->s_stat, i = 0; i < st->s_nstat; i++, dst++) {
280
281 DBG("ds_name,ds_unit,ds_type=<%s,%d,%d> ",
282 dst->ds_name, dst->ds_unit, dst->ds_type);
283
284 if (dst->ds_unit != a->cnum)
285 continue;
286
287 /*
288 * Consider the names matched if they are either
289 * both absent or the same. It is conceivable that
290 * a NULL component name be considered valid
291 * by the driver.
292 */
293 dn = dst->ds_name;
294
295 if ((dn == NULL && cn == NULL) ||
296 (dn != NULL && cn != NULL && strcmp(dn, cn) == 0)) {
297 a->tgt = ap_cm_tgt(dst->ds_type);
298 a->cmstat = (void *)dst;
299
300 DBG("found ");
301
302 break;
303 }
304 }
305
306 DBG("tgt=%d\n", a->tgt);
307
308 if (a->tgt == AP_NONE) {
309 ap_err(a, ERR_CM_INVAL, a->cid);
310 return (CFGA_INVAL);
311 }
312
313 /*
314 * Initialize the RCM module here so that it can record
315 * the initial state of the capacity information.
316 */
317 rc = ap_rcm_init(a);
318
319 return (rc);
320 }
321
322 void
apd_free(apd_t * a)323 apd_free(apd_t *a)
324 {
325 if (a == NULL)
326 return;
327
328 ap_rcm_fini(a);
329
330 if (a->fd != -1)
331 (void) close(a->fd);
332
333 s_free(a->options);
334 s_free(a->path);
335 s_free(a->drv);
336 s_free(a->target);
337 s_free(a->cname);
338 s_free(a->ctl);
339 s_free(a->stat);
340
341 free(a);
342 }
343
344 apd_t *
apd_alloc(const char * ap_id,cfga_flags_t flags,char ** errstring,struct cfga_msg * msgp,struct cfga_confirm * confp)345 apd_alloc(const char *ap_id, cfga_flags_t flags, char **errstring,
346 struct cfga_msg *msgp, struct cfga_confirm *confp)
347 {
348 apd_t *a;
349
350 if ((a = calloc(1, sizeof (*a))) == NULL)
351 return (NULL);
352
353 if (errstring != NULL)
354 *errstring = NULL;
355
356 a->fd = -1;
357 a->errstring = errstring;
358 a->msgp = msgp;
359 a->confp = confp;
360 a->class = "sbd";
361
362 if (flags & CFGA_FLAG_LIST_ALL)
363 ap_setopt(a, OPT_LIST_ALL);
364 if (flags & CFGA_FLAG_FORCE)
365 ap_setopt(a, OPT_FORCE);
366 if (flags & CFGA_FLAG_VERBOSE)
367 ap_setopt(a, OPT_VERBOSE);
368
369 if (ap_id == NULL || ap_parse(a, ap_id) == 0)
370 return (a);
371
372 apd_free(a);
373 return (NULL);
374 }
375
376 /*
377 * The type field is defined to be parsable by cfgadm(8): It
378 * must not contain white space characters. This function
379 * converts white space to underscore.
380 */
381
382 static void
parsable_strncpy(char * op,const char * ip,size_t n)383 parsable_strncpy(char *op, const char *ip, size_t n)
384 {
385 char c;
386
387 while (n-- > 0) {
388 c = *ip++;
389 if (isspace(c))
390 c = '_';
391 *op++ = c;
392 if (c == '\0')
393 break;
394 }
395 }
396
397 void
ap_init(apd_t * a,cfga_list_data_t * ap)398 ap_init(apd_t *a, cfga_list_data_t *ap)
399 {
400 sbd_stat_t *st;
401
402 st = (sbd_stat_t *)a->stat;
403
404 DBG("ap_init bd=%d rs=%d os=%d type=<%s>\n",
405 a->bnum, st->s_rstate, st->s_ostate, st->s_type);
406
407 parsable_strncpy(ap->ap_type, st->s_type, sizeof (ap->ap_type));
408 ap->ap_r_state = (cfga_stat_t)st->s_rstate;
409 ap->ap_o_state = (cfga_stat_t)st->s_ostate;
410 ap->ap_cond = (cfga_cond_t)st->s_cond;
411 ap->ap_busy = (cfga_busy_t)st->s_busy;
412 ap->ap_status_time = st->s_time;
413 ap_info(a, ap->ap_info, AP_BOARD);
414 }
415
416 typedef struct {
417 int cmd;
418 int ioc;
419 } ap_ioc_t;
420
421 static ap_ioc_t
422 ap_iocs[] = {
423 {CMD_ASSIGN, SBD_CMD_ASSIGN },
424 {CMD_POWERON, SBD_CMD_POWERON },
425 {CMD_TEST, SBD_CMD_TEST },
426 {CMD_CONNECT, SBD_CMD_CONNECT },
427 {CMD_CONFIGURE, SBD_CMD_CONFIGURE },
428 {CMD_UNCONFIGURE, SBD_CMD_UNCONFIGURE },
429 {CMD_DISCONNECT, SBD_CMD_DISCONNECT },
430 {CMD_POWEROFF, SBD_CMD_POWEROFF },
431 {CMD_STATUS, SBD_CMD_STATUS },
432 {CMD_GETNCM, SBD_CMD_GETNCM },
433 {CMD_UNASSIGN, SBD_CMD_UNASSIGN },
434 {CMD_PASSTHRU, SBD_CMD_PASSTHRU },
435 {CMD_NONE, 0 }
436 };
437
438 static int
ap_ioc(int cmd)439 ap_ioc(int cmd)
440 {
441 ap_ioc_t *acp;
442
443 DBG("ap_ioc(%d)\n", cmd);
444
445 for (acp = ap_iocs; acp->cmd != CMD_NONE; acp++)
446 if (acp->cmd == cmd)
447 break;
448
449 DBG("ap_ioc(%d)=0x%x\n", cmd, acp->ioc);
450
451 return (acp->ioc);
452 }
453
454 cfga_err_t
ap_suspend_query(apd_t * a,int cmd,int * check)455 ap_suspend_query(apd_t *a, int cmd, int *check)
456 {
457 int ioc;
458 sbd_dev_stat_t *dst;
459
460 /*
461 * See if the a quiesce operation is required for
462 * this command for any of the components. If the
463 * command does not map to an ioctl, then there is
464 * nothing to do.
465 */
466 if ((ioc = ap_ioc(cmd)) == 0)
467 return (CFGA_OK);
468 else if (a->tgt == AP_BOARD) {
469 int i;
470
471 dst = ((sbd_stat_t *)a->stat)->s_stat;
472
473 /*
474 * See if any component requires a
475 * OS suspension for this command.
476 */
477 for (i = 0; i < a->ncm; i++, dst++)
478 if (SBD_CHECK_SUSPEND(ioc, dst->ds_suspend))
479 (*check)++;
480 } else {
481 dst = (sbd_dev_stat_t *)a->cmstat;
482 if (SBD_CHECK_SUSPEND(ioc, dst->ds_suspend))
483 (*check)++;
484 }
485
486 return (CFGA_OK);
487 }
488
489 cfga_err_t
ap_platopts_check(apd_t * a,int first,int last)490 ap_platopts_check(apd_t *a, int first, int last)
491 {
492 int c;
493 uint_t platopts;
494 sbd_stat_t *stat;
495 ap_opts_t *opts;
496
497 opts = &a->opts;
498 stat = (sbd_stat_t *)a->stat;
499 platopts = stat->s_platopts;
500
501
502 /*
503 * If there are no platform options set then there
504 * is no need to check this operation
505 */
506 if (opts->platform == NULL)
507 return (CFGA_OK);
508
509 /*
510 * Check if any of the steps in the sequence
511 * allows for a platform option
512 */
513 for (c = first; c <= last; c++)
514 /*
515 * If the platopt is set it means that the platform does not
516 * support options for this cmd
517 */
518 if (SBD_CHECK_PLATOPTS(ap_ioc(c), platopts) == 0) {
519 return (CFGA_OK);
520 }
521
522 ap_err(a, ERR_OPT_INVAL, opts->platform);
523
524 return (CFGA_INVAL);
525 }
526
527 cfga_err_t
ap_ioctl(apd_t * a,int cmd)528 ap_ioctl(apd_t *a, int cmd)
529 {
530 int ioc;
531 sbd_ioctl_arg_t *ctl;
532
533 if (a->ctl == NULL && (a->ctl = calloc(1, sizeof (*ctl))) == NULL) {
534 ap_err(a, ERR_CMD_FAIL, cmd);
535 return (CFGA_LIB_ERROR);
536 }
537
538 ap_msg(a, MSG_ISSUE, cmd, a->target);
539
540 ctl = (sbd_ioctl_arg_t *)a->ctl;
541 ctl->i_flags = 0;
542 ctl->i_len = 0;
543 ctl->i_opts = NULL;
544
545 if (ap_getopt(a, OPT_FORCE))
546 ctl->i_flags |= SBD_FLAG_FORCE;
547 if (ap_getopt(a, OPT_SUSPEND_OK))
548 ctl->i_flags |= SBD_FLAG_QUIESCE_OKAY;
549
550 if (a->tgt == AP_BOARD)
551 ctl->ic_type = SBD_COMP_NONE;
552 else {
553 ctl->ic_type = SBD_COMP_UNKNOWN;
554 ctl->ic_unit = a->cnum;
555 (void) strcpy(ctl->ic_name, a->cname);
556 }
557
558 if (!(ioc = ap_ioc(cmd))) {
559 ap_err(a, ERR_CMD_FAIL, cmd);
560 return (CFGA_LIB_ERROR);
561 }
562
563 /*
564 * If this is a passthru command, pass all of its
565 * options; otherwise, pass all options after the
566 * platform keyword.
567 */
568 if (cmd == CMD_PASSTHRU)
569 ctl->i_opts = a->options;
570 else {
571 /*
572 * Only pass the platform option to the cmds that the platform
573 * has specified as ok
574 */
575 sbd_stat_t *stat;
576
577 stat = (sbd_stat_t *)a->stat;
578 if (SBD_CHECK_PLATOPTS(ioc, stat->s_platopts) == 0)
579 ctl->i_opts = a->opts.platform;
580 }
581
582 if (ctl->i_opts != NULL)
583 ctl->i_len = strlen(ctl->i_opts) + 1;
584
585 DBG("i_opts=%s\n", ctl->i_opts ? ctl->i_opts : "NULL");
586 DBG("i_flags=0x%x\n", ctl->i_flags);
587
588 if (ap_getopt(a, OPT_SIM)) {
589 ap_msg(a, MSG_DONE, cmd, a->target);
590 return (CFGA_OK);
591 }
592
593 if (ioctl(a->fd, ioc, ctl) == -1) {
594 ap_err(a, ERR_CMD_FAIL, cmd);
595 return (CFGA_ERROR);
596 }
597 ap_msg(a, MSG_DONE, cmd, a->target);
598
599 return (CFGA_OK);
600 }
601
602 /*
603 * Return the error string corresponding to a given error code.
604 * String table and error code sets are provided by sbd_etab. This data
605 * structure is automatically generated at compile time from the error
606 * code and message text information in sbd_ioctl.h.
607 */
608 static char *
mod_estr(int code)609 mod_estr(int code)
610 {
611 int i;
612 char *s;
613 extern sbd_etab_t sbd_etab[];
614 extern int sbd_etab_len;
615
616 s = NULL;
617
618 for (i = 0; i < sbd_etab_len; i++) {
619 sbd_etab_t *eptr = &sbd_etab[i];
620
621 if ((code >= eptr->t_base) && (code <= eptr->t_bnd)) {
622 int index;
623 char **t_text;
624
625 /*
626 * Found it. Just extract the string
627 */
628 index = code - eptr->t_base;
629 t_text = eptr->t_text;
630 s = strdup(t_text[index]);
631 break;
632 }
633 }
634
635 if (i == sbd_etab_len) {
636 char buf[32];
637
638 (void) snprintf(buf, sizeof (buf), "error %d", code);
639 s = strdup(buf);
640 }
641
642 return (s);
643 }
644
645 char *
ap_sys_err(apd_t * a,char ** rp)646 ap_sys_err(apd_t *a, char **rp)
647 {
648 int code;
649 char *p;
650 char *rsc;
651
652 sbd_ioctl_arg_t *ctl = (sbd_ioctl_arg_t *)a->ctl;
653
654 /*
655 * The driver sets the errno to EIO if it returns
656 * more detailed error info via e_code. In all
657 * other cases, use standard error text.
658 */
659 if (ctl == NULL || errno != EIO) {
660 if ((p = strerror(errno)) != NULL)
661 p = strdup(p);
662 return (p);
663 }
664
665 code = ctl->ie_code;
666 rsc = ctl->ie_rsc;
667
668 if (code)
669 p = mod_estr(code);
670 else if ((p = strerror(errno)) != NULL)
671 p = strdup(p);
672
673 if (*rsc != '\0' && rp != NULL)
674 *rp = strdup(rsc);
675
676 return (p);
677 }
678
679 /*
680 * cfgadm -o err=plugin-err,cmd=name,code=ecode -x errtest ap_id.
681 */
682 cfga_err_t
ap_test_err(apd_t * a,const char * options)683 ap_test_err(apd_t *a, const char *options)
684 {
685 int err;
686 int cmd;
687 ap_opts_t *opts;
688 sbd_ioctl_arg_t ctl;
689
690 opts = &a->opts;
691 err = opts->err;
692 cmd = CMD_DISCONNECT;
693
694 DBG("ap_test_err(%d %d)\n", opts->code, opts->err);
695
696 switch (err) {
697 case ERR_CMD_INVAL:
698 ap_err(a, err, ap_cmd_name(cmd));
699 break;
700 case ERR_CMD_NOTSUPP:
701 ap_err(a, err, cmd);
702 break;
703 case ERR_CMD_FAIL:
704 errno = EIO;
705 ctl.i_err.e_code = opts->code;
706 *ctl.i_err.e_rsc = '\0';
707 a->ctl = &ctl;
708 ap_err(a, err, cmd);
709 a->ctl = NULL;
710 break;
711 case ERR_OPT_INVAL:
712 ap_err(a, err, options);
713 break;
714 case ERR_OPT_NOVAL:
715 ap_err(a, err, options);
716 break;
717 case ERR_AP_INVAL:
718 ap_err(a, err);
719 break;
720 case ERR_CM_INVAL:
721 ap_err(a, err, a->cid);
722 break;
723 case ERR_TRANS_INVAL:
724 ap_err(a, ERR_TRANS_INVAL, cmd);
725 break;
726 }
727
728 return (CFGA_LIB_ERROR);
729 }
730
731 static char *
732 ap_help_topics[] = {
733 "\nSbd specific commands/options:\n\n",
734 "\tcfgadm [-o parsable] -l ap_id\n",
735 "\tcfgadm [-o unassign|nopoweroff] -c disconnect ap_id\n",
736 "\tcfgadm -t ap_id\n",
737 "\tcfgadm -x assign ap_id\n",
738 "\tcfgadm -x unassign ap_id\n",
739 "\tcfgadm -x poweron ap_id\n",
740 "\tcfgadm -x poweroff ap_id\n",
741 NULL
742 };
743
744 /*ARGSUSED*/
745 cfga_err_t
ap_help(struct cfga_msg * msgp,const char * options,cfga_flags_t flags)746 ap_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags)
747 {
748 int len;
749 char **p;
750 char *q;
751
752 if (msgp == NULL || msgp->message_routine == NULL)
753 return (CFGA_OK);
754
755 for (p = ap_help_topics; *p != NULL; p++) {
756 if ((len = strlen(*p)) == 0)
757 continue;
758 if ((q = (char *)calloc(len + 1, 1)) == NULL)
759 continue;
760 (void) strcpy(q, *p);
761 (*msgp->message_routine)(msgp->appdata_ptr, q);
762 free(q);
763 }
764
765 return (CFGA_OK);
766 }
767
768 static char *
ap_dev_type(sbd_dev_stat_t * dst)769 ap_dev_type(sbd_dev_stat_t *dst)
770 {
771 char *type;
772
773 switch (dst->ds_type) {
774 case SBD_COMP_CPU:
775 type = "cpu";
776 break;
777 case SBD_COMP_MEM:
778 type = "memory";
779 break;
780 case SBD_COMP_IO:
781 type = "io";
782 break;
783 case SBD_COMP_CMP:
784 type = "cpu";
785 break;
786 default:
787 type = "other";
788 break;
789 }
790
791 DBG("ap_dev_type(%d)=%s\n", dst->ds_type, type);
792
793 return (type);
794 }
795
796 static sbd_dev_stat_t *
ap_cm_stat(apd_t * a,int seq)797 ap_cm_stat(apd_t *a, int seq)
798 {
799 sbd_stat_t *st;
800
801 if (seq == CM_DFLT)
802 return (a->cmstat);
803
804 st = (sbd_stat_t *)a->stat;
805 return (st->s_stat + seq);
806 }
807
808 char *
ap_cm_devpath(apd_t * a,int seq)809 ap_cm_devpath(apd_t *a, int seq)
810 {
811 int len;
812 char *path;
813 char *devpath;
814 sbd_io_stat_t *dst;
815
816
817 /*
818 * If no component sequence number is provided
819 * default to the current target component.
820 * Assume an io component so that we can get
821 * the path if the component is indeed of type io.
822 */
823 if (seq == CM_DFLT)
824 dst = (sbd_io_stat_t *)a->cmstat;
825 else {
826 sbd_stat_t *st;
827 st = (sbd_stat_t *)a->stat;
828 dst = (sbd_io_stat_t *)st->s_stat + seq;
829 }
830
831 if (dst->is_type != SBD_COMP_IO)
832 path = NULL;
833 else
834 path = dst->is_pathname;
835
836 if (str_valid(path)) {
837 len = strlen(DEVDIR) + strlen(path) + 1;
838
839 if ((devpath = calloc(1, len)) == NULL)
840 return (NULL);
841
842 (void) snprintf(devpath, len, "%s%s", DEVDIR, path);
843 } else
844 devpath = NULL;
845
846 DBG("ap_cm_path(%d)=%s\n", seq, devpath ? devpath : "");
847
848 return (devpath);
849 }
850
851 void
ap_cm_id(apd_t * a,int seq,char * id,size_t bufsize)852 ap_cm_id(apd_t *a, int seq, char *id, size_t bufsize)
853 {
854 int unit;
855 char *name;
856 sbd_dev_stat_t *dst;
857
858 dst = ap_cm_stat(a, seq);
859
860 unit = dst->ds_unit;
861 name = dst->ds_name;
862
863 /*
864 * If the component has a unit number,
865 * add it to the id, otherwise just use
866 * the component's name.
867 */
868 if (unit == -1)
869 (void) snprintf(id, bufsize, "%s", name);
870 else
871 (void) snprintf(id, bufsize, "%s%d", name, unit);
872
873 DBG("ap_cm_id(%d)=%s\n", seq, id);
874 }
875
876 /*
877 * Convert a component to a target type.
878 */
879 ap_target_t
ap_cm_type(apd_t * a,int seq)880 ap_cm_type(apd_t *a, int seq)
881 {
882 ap_target_t c;
883 sbd_dev_stat_t *dst;
884
885 dst = ap_cm_stat(a, seq);
886
887 switch (dst->ds_type) {
888 case SBD_COMP_CPU:
889 c = AP_CPU;
890 break;
891 case SBD_COMP_MEM:
892 c = AP_MEM;
893 break;
894 case SBD_COMP_IO:
895 c = AP_IO;
896 break;
897 case SBD_COMP_CMP:
898 c = AP_CMP;
899 break;
900 default:
901 c = AP_NONE;
902 break;
903 }
904
905 return (c);
906 }
907
908 int
ap_cm_ncap(apd_t * a,int seq)909 ap_cm_ncap(apd_t *a, int seq)
910 {
911 sbd_dev_stat_t *dst;
912 int ncap;
913
914 dst = ap_cm_stat(a, seq);
915
916 switch (dst->ds_type) {
917 case SBD_COMP_CPU:
918 case SBD_COMP_MEM:
919 case SBD_COMP_IO:
920 ncap = 1;
921 break;
922 case SBD_COMP_CMP:
923 ncap = ((sbd_cmp_stat_t *)dst)->ps_ncores;
924 break;
925 default:
926 ncap = 0;
927 break;
928 }
929
930 return (ncap);
931 }
932
933 int
ap_cm_capacity(apd_t * a,int seq,void * cap,int * ncap,cfga_stat_t * ostate)934 ap_cm_capacity(apd_t *a, int seq, void *cap, int *ncap, cfga_stat_t *ostate)
935 {
936 int i;
937 sbd_dev_stat_t *dst;
938 cfga_stat_t os;
939
940 if (cap == NULL)
941 return (0);
942
943 dst = ap_cm_stat(a, seq);
944 os = (cfga_stat_t)dst->ds_ostate;
945 if (os != CFGA_STAT_CONFIGURED && os != CFGA_STAT_UNCONFIGURED)
946 return (0);
947 if (ostate)
948 *ostate = os;
949
950 *ncap = 1;
951
952 switch (dst->ds_type) {
953 case SBD_COMP_CPU: {
954 sbd_cpu_stat_t *cpu = (sbd_cpu_stat_t *)dst;
955 *((processorid_t *)cap) = cpu->cs_cpuid;
956 break;
957 }
958 case SBD_COMP_MEM: {
959 sbd_mem_stat_t *mem = (sbd_mem_stat_t *)dst;
960 *((long *)cap) = mem->ms_totpages;
961 break;
962 }
963 case SBD_COMP_CMP: {
964 sbd_cmp_stat_t *cmp = (sbd_cmp_stat_t *)dst;
965 processorid_t *cpuid;
966
967 cpuid = (processorid_t *)cap;
968 for (i = 0; i < cmp->ps_ncores; i++) {
969 cpuid[i] = cmp->ps_cpuid[i];
970 }
971
972 *ncap = cmp->ps_ncores;
973 break;
974 }
975 default:
976 return (0);
977 }
978
979 DBG("ap_cm_capacity(%d)=(", seq);
980 for (i = 0; i < *ncap; i++) {
981 DBG("%d ", ((int *)cap)[i]);
982 }
983 DBG("%d)\n", *ostate);
984
985 return (1);
986 }
987
988 void
ap_cm_init(apd_t * a,cfga_list_data_t * ap,int seq)989 ap_cm_init(apd_t *a, cfga_list_data_t *ap, int seq)
990 {
991 char *type;
992 sbd_stat_t *st;
993 sbd_dev_stat_t *dst;
994
995 st = (sbd_stat_t *)a->stat;
996 dst = st->s_stat + seq;
997 type = ap_dev_type(dst);
998
999 a->cmstat = (void *)dst;
1000
1001 DBG("ap_cm_init bd=%d rs=%d os=%d type=<%s> seq=%d\n",
1002 a->bnum, st->s_rstate, dst->ds_ostate, type, seq);
1003
1004 (void) strncpy(ap->ap_type, type, sizeof (ap->ap_type));
1005 ap->ap_r_state = (cfga_stat_t)st->s_rstate;
1006 ap->ap_o_state = (cfga_stat_t)dst->ds_ostate;
1007 ap->ap_cond = (cfga_cond_t)dst->ds_cond;
1008 ap->ap_busy = (cfga_busy_t)dst->ds_busy;
1009 ap->ap_status_time = dst->ds_time;
1010 ap_info(a, ap->ap_info, ap_cm_tgt(dst->ds_type));
1011 }
1012
1013 void
ap_state(apd_t * a,cfga_stat_t * rs,cfga_stat_t * os)1014 ap_state(apd_t *a, cfga_stat_t *rs, cfga_stat_t *os)
1015 {
1016 sbd_stat_t *st;
1017 sbd_dev_stat_t *dst;
1018
1019 st = (sbd_stat_t *)a->stat;
1020 dst = (sbd_dev_stat_t *)a->cmstat;
1021
1022 if (rs != NULL) {
1023 if (a->tgt == AP_NONE)
1024 *rs = CFGA_STAT_NONE;
1025 else
1026 *rs = (cfga_stat_t)st->s_rstate;
1027 }
1028
1029 if (os != NULL) {
1030 if (a->tgt == AP_NONE)
1031 *os = CFGA_STAT_NONE;
1032 else if (a->tgt == AP_BOARD)
1033 *os = (cfga_stat_t)st->s_ostate;
1034 else
1035 *os = (cfga_stat_t)dst->ds_ostate;
1036 }
1037 }
1038
1039 #define BI_POWERED 0
1040 #define BI_ASSIGNED 1
1041
1042 static const char *
1043 binfo[] = {
1044 "powered-on",
1045 ", assigned"
1046 };
1047
1048 static const char *
1049 binfo_parsable[] = {
1050 "powered-on",
1051 " assigned"
1052 };
1053
1054 static void
bd_info(apd_t * a,cfga_info_t info,int parsable)1055 bd_info(apd_t *a, cfga_info_t info, int parsable)
1056 {
1057 int i;
1058 int nsep;
1059 const char **p;
1060 sbd_stat_t *st;
1061 char *end = &info[sizeof (cfga_info_t)];
1062
1063 DBG("bd_info(%p)\n", (void *)info);
1064
1065 st = (sbd_stat_t *)a->stat;
1066
1067 if (parsable) {
1068 p = binfo_parsable;
1069 nsep = 1;
1070 } else {
1071 p = binfo;
1072 nsep = 2;
1073 }
1074
1075 i = nsep;
1076
1077 if (st->s_power) {
1078 info += snprintf(info, end - info, p[BI_POWERED]);
1079 i = 0;
1080 }
1081 if (st->s_assigned)
1082 info += snprintf(info, end - info, p[BI_ASSIGNED] + i);
1083 }
1084
1085 #define CI_CPUID 0
1086 #define CI_SPEED 1
1087 #define CI_ECACHE 2
1088
1089 static const char *
1090 cpuinfo[] = {
1091 "cpuid %d",
1092 ", speed %d MHz",
1093 ", ecache %d MBytes"
1094 };
1095
1096 static const char *
1097 cpuinfo_parsable[] = {
1098 "cpuid=%d",
1099 " speed=%d",
1100 " ecache=%d"
1101 };
1102
1103 static void
cpu_info(apd_t * a,cfga_info_t info,int parsable)1104 cpu_info(apd_t *a, cfga_info_t info, int parsable)
1105 {
1106 const char **p;
1107 sbd_cpu_stat_t *dst;
1108 char *end = &info[sizeof (cfga_info_t)];
1109
1110 DBG("cpu_info(%p)\n", (void *)info);
1111
1112 dst = (sbd_cpu_stat_t *)a->cmstat;
1113
1114 if (parsable)
1115 p = cpuinfo_parsable;
1116 else
1117 p = cpuinfo;
1118
1119 info += snprintf(info, end - info, p[CI_CPUID], dst->cs_cpuid);
1120 info += snprintf(info, end - info, p[CI_SPEED], dst->cs_speed);
1121 info += snprintf(info, end - info, p[CI_ECACHE], dst->cs_ecache);
1122 }
1123
1124 #define MI_ADDRESS 0
1125 #define MI_SIZE 1
1126 #define MI_PERMANENT 2
1127 #define MI_UNCONFIGURABLE 3
1128 #define MI_SOURCE 4
1129 #define MI_TARGET 5
1130 #define MI_DELETED 6
1131 #define MI_REMAINING 7
1132 #define MI_INTERLEAVE 8
1133
1134 static const char *
1135 meminfo_nonparsable[] = {
1136 "base address 0x%" PRIx64,
1137 ", %lu KBytes total",
1138 ", %lu KBytes permanent",
1139 ", unconfigurable",
1140 ", memory delete requested on %s",
1141 ", memory delete in progress on %s",
1142 ", %lu KBytes deleted",
1143 ", %lu KBytes remaining",
1144 ", inter board interleave"
1145 };
1146
1147 static const char *
1148 meminfo_parsable[] = {
1149 "address=0x%" PRIx64,
1150 " size=%lu",
1151 " permanent=%lu",
1152 " unconfigurable",
1153 " source=%s",
1154 " target=%s",
1155 " deleted=%lu",
1156 " remaining=%lu",
1157 " inter-board-interleave"
1158 };
1159
1160
1161 #define _K1 1024
1162
1163 /*
1164 * This function assumes pagesize > 1024 and that
1165 * pagesize is a multiple of 1024.
1166 */
1167 static ulong_t
pages_to_kbytes(uint_t pgs)1168 pages_to_kbytes(uint_t pgs)
1169 {
1170 long pagesize;
1171
1172 pagesize = sysconf(_SC_PAGESIZE);
1173 return (pgs * (pagesize / _K1));
1174 }
1175
1176 static uint64_t
pages_to_bytes(uint_t pgs)1177 pages_to_bytes(uint_t pgs)
1178 {
1179 long pagesize;
1180
1181 pagesize = sysconf(_SC_PAGESIZE);
1182 return ((uint64_t)pgs * pagesize);
1183 }
1184
1185 static void
mem_info(apd_t * a,cfga_info_t info,int parsable)1186 mem_info(apd_t *a, cfga_info_t info, int parsable)
1187 {
1188 const char **p;
1189 sbd_mem_stat_t *dst;
1190 int want_progress;
1191 char *end = &info[sizeof (cfga_info_t)];
1192
1193 DBG("mem_info(%p)\n", (void *)info);
1194
1195 dst = (sbd_mem_stat_t *)a->cmstat;
1196
1197 if (parsable)
1198 p = meminfo_parsable;
1199 else
1200 p = meminfo_nonparsable;
1201
1202 info += snprintf(info, end - info, p[MI_ADDRESS],
1203 pages_to_bytes(dst->ms_basepfn));
1204 info += snprintf(info, end - info, p[MI_SIZE],
1205 pages_to_kbytes(dst->ms_totpages));
1206
1207 if (dst->ms_noreloc_pages)
1208 info += snprintf(info, end - info, p[MI_PERMANENT],
1209 pages_to_kbytes(dst->ms_noreloc_pages));
1210 if (!dst->ms_cage_enabled)
1211 info += snprintf(info, end - info, p[MI_UNCONFIGURABLE]);
1212 if (dst->ms_interleave)
1213 info += snprintf(info, end - info, p[MI_INTERLEAVE]);
1214
1215 /*
1216 * If there is a valid peer physical ap_id specified,
1217 * convert it to a logical id.
1218 */
1219 want_progress = 0;
1220 if (str_valid(dst->ms_peer_ap_id)) {
1221 char *cm;
1222 char *peer;
1223 char physid[MAXPATHLEN];
1224 char logid[MAXPATHLEN];
1225
1226 (void) snprintf(physid, sizeof (physid), "%s%s",
1227 DEVDIR, dst->ms_peer_ap_id);
1228
1229 /*
1230 * Save the component portion of the physid and
1231 * add it back after converting to logical format.
1232 */
1233 if ((cm = strstr(physid, "::")) != NULL) {
1234 *cm = '\0';
1235 cm += 2;
1236 }
1237
1238 /* attempt to resolve to symlink */
1239 if (ap_symid(a, physid, logid, sizeof (logid)) == 0)
1240 peer = logid;
1241 else
1242 peer = physid;
1243
1244 if (dst->ms_peer_is_target) {
1245 info += snprintf(info, end - info, p[MI_TARGET], peer);
1246 if (cm)
1247 info += snprintf(info, end - info, "::%s", cm);
1248 want_progress = 1;
1249 } else {
1250 info += snprintf(info, end - info, p[MI_SOURCE], peer);
1251 if (cm)
1252 info += snprintf(info, end - info, "::%s", cm);
1253 }
1254 }
1255 if (want_progress ||
1256 (dst->ms_detpages != 0 && dst->ms_detpages != dst->ms_totpages)) {
1257 info += snprintf(info, end - info, p[MI_DELETED],
1258 pages_to_kbytes(dst->ms_detpages));
1259 info += snprintf(info, end - info, p[MI_REMAINING],
1260 pages_to_kbytes(dst->ms_totpages -
1261 dst->ms_detpages));
1262 }
1263 }
1264
1265 #define II_DEVICE 0
1266 #define II_REFERENCED 1
1267
1268 static const char *
1269 ioinfo[] = {
1270 "device %s",
1271 ", referenced"
1272 };
1273
1274 static const char *
1275 ioinfo_parsable[] = {
1276 "device=%s",
1277 " referenced"
1278 };
1279
1280 static void
io_info(apd_t * a,cfga_info_t info,int parsable)1281 io_info(apd_t *a, cfga_info_t info, int parsable)
1282 {
1283 const char **p;
1284 sbd_io_stat_t *dst;
1285 char *end = &info[sizeof (cfga_info_t)];
1286
1287 dst = (sbd_io_stat_t *)a->cmstat;
1288
1289 if (parsable)
1290 p = ioinfo_parsable;
1291 else
1292 p = ioinfo;
1293
1294 info += snprintf(info, end - info, p[II_DEVICE], dst->is_pathname);
1295 if (dst->is_referenced)
1296 info += snprintf(info, end - info, p[II_REFERENCED]);
1297 }
1298
1299 #define PI_CPUID 0
1300 #define PI_CPUID_PAIR 1
1301 #define PI_CPUID_CONT 2
1302 #define PI_CPUID_LAST 3
1303 #define PI_SPEED 4
1304 #define PI_ECACHE 5
1305
1306 static const char *
1307 cmpinfo[] = {
1308 "cpuid %d",
1309 " and %d",
1310 ", %d",
1311 ", and %d",
1312 ", speed %d MHz",
1313 ", ecache %d MBytes"
1314 };
1315
1316 static const char *
1317 cmpinfo_parsable[] = {
1318 "cpuid=%d",
1319 ",%d",
1320 ",%d",
1321 ",%d",
1322 " speed=%d",
1323 " ecache=%d"
1324 };
1325
1326 static void
cmp_info(apd_t * a,cfga_info_t info,int parsable)1327 cmp_info(apd_t *a, cfga_info_t info, int parsable)
1328 {
1329 int i;
1330 int last;
1331 const char **p;
1332 sbd_cmp_stat_t *dst;
1333 char *end = &info[sizeof (cfga_info_t)];
1334
1335 DBG("cmp_info(%p)\n", (void *)info);
1336
1337 dst = (sbd_cmp_stat_t *)a->cmstat;
1338
1339 if (parsable)
1340 p = cmpinfo_parsable;
1341 else
1342 p = cmpinfo;
1343
1344 /* Print the first cpuid */
1345 info += snprintf(info, end - info, p[PI_CPUID], dst->ps_cpuid[0]);
1346
1347 /*
1348 * Print the middle cpuids, if necessary. Stop before
1349 * the last one, since printing the last cpuid is a
1350 * special case for the non parsable form.
1351 */
1352 for (i = 1; i < (dst->ps_ncores - 1); i++) {
1353 info += snprintf(info, end - info, p[PI_CPUID_CONT],
1354 dst->ps_cpuid[i]);
1355 }
1356
1357 /* Print the last cpuid, if necessary */
1358 if (dst->ps_ncores > 1) {
1359 last = (dst->ps_ncores == 2) ? PI_CPUID_PAIR : PI_CPUID_LAST;
1360 info += snprintf(info, end - info,
1361 dgettext(TEXT_DOMAIN, p[last]), dst->ps_cpuid[i]);
1362 }
1363
1364 info += snprintf(info, end - info, p[PI_SPEED], dst->ps_speed);
1365 info += snprintf(info, end - info, p[PI_ECACHE], dst->ps_ecache);
1366 }
1367
1368 void
ap_info(apd_t * a,cfga_info_t info,ap_target_t tgt)1369 ap_info(apd_t *a, cfga_info_t info, ap_target_t tgt)
1370 {
1371 int parsable = ap_getopt(a, OPT_PARSABLE);
1372
1373 DBG("ap_info(%p, %d)\n", (void *)info, parsable);
1374
1375 switch (tgt) {
1376 case AP_BOARD:
1377 bd_info(a, info, parsable);
1378 break;
1379 case AP_CPU:
1380 cpu_info(a, info, parsable);
1381 break;
1382 case AP_MEM:
1383 mem_info(a, info, parsable);
1384 break;
1385 case AP_IO:
1386 io_info(a, info, parsable);
1387 break;
1388 case AP_CMP:
1389 cmp_info(a, info, parsable);
1390 break;
1391 default:
1392 break;
1393 }
1394 }
1395