?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / picl / plugins / sun4u / envmon / piclenvmon.c
blobf1d69ccc5c8800c144f2407063be63e5351cf42d
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 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This plugin creates PICL nodes and properties for objects handled through
31 * the enhanced LOMV system-processor interface.
32 *
33 * All the nodes which may be accessible through the system-processor are
34 * included below the service-processor node in the /platform tree.
35 * This plugin interrogates the system-processor to determine which of
36 * those nodes are actually available. Properties are added to such nodes and
37 * in the case of volatile properties like temperature, a call-back function
38 * is established for on-demand access to the current value.
39 * LEDs for which the system-processor provides write access are associated
40 * with read/write volatile properties.
41 *
42 * NOTE:
43 * Depends on PICL devtree plugin.
44 */
45
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <unistd.h>
49 #include <fcntl.h>
50 #include <alloca.h>
51 #include <syslog.h>
52 #include <string.h>
53 #include <libintl.h>
54 #include <picl.h>
55 #include <picltree.h>
56 #include <libnvpair.h>
57 #include <errno.h>
58 #include <limits.h>
59 #include <ctype.h>
60 #include <sys/types.h>
61 #include <sys/stat.h>
62 #include <sys/obpdefs.h>
63 #include <sys/envmon.h>
64 #include <sys/systeminfo.h>
65 #include <dirent.h>
66 #include <time.h>
67 #include <picldefs.h>
68 #include <picld_pluginutil.h>
69 #include <libdevinfo.h>
70 #include "piclenvmon.h"
71
72 static void piclenvmon_register(void);
73 static void piclenvmon_init(void);
74 static void piclenvmon_fini(void);
75 static node_el_t *create_node_el(picl_nodehdl_t nodeh);
76 static void delete_node_el(node_el_t *pel);
77 static node_list_t *create_node_list();
78 static void delete_node_list(node_list_t *pnl);
79 static void add_node_to_list(picl_nodehdl_t nodeh, node_list_t *listp);
80 static void get_node_list_by_class(picl_nodehdl_t nodeh,
81 const char *classname, node_list_t *listp);
82 static int get_envmon_limits(int envmon_fd, envmon_sysinfo_t *limits_p);
83 static void create_arrays();
84 static int get_envmon_node(picl_nodehdl_t *envmoninfh);
85 static char *create_envmon_pathname(picl_nodehdl_t envmoninfh);
86 static int get_child_by_name(picl_nodehdl_t nodeh, const char *name,
87 picl_nodehdl_t *childh);
88 static int add_regular_prop(picl_nodehdl_t nodeh, const char *name,
89 int type, int access, int size, const void *valbuf, picl_prophdl_t *prophp);
90 static int add_volatile_prop(picl_nodehdl_t nodeh, const char *name,
91 int type, int access, int size, ptree_vol_rdfunc_t rdfunc,
92 ptree_vol_wrfunc_t wrfunc, picl_prophdl_t *prophp);
93 static int get_sensor_data(int envmon_fd, envmon_handle_t *id, int cmd,
94 envmon_thresholds_t *lows, envmon_thresholds_t *highs, int16_t *value);
95 static int get_indicator_data(int envmon_fd, envmon_handle_t *id, int cmd,
96 int16_t *condition);
97 static int get_fan_data(int envmon_fd, envmon_handle_t *id, int cmd,
98 envmon_thresholds_t *lows, uint16_t *speed, char *units);
99 static int get_led_data(int envmon_fd, envmon_handle_t *id, int cmd,
100 int8_t *state, int8_t *colour);
101 static int get_keyswitch_data(int envmon_fd, envmon_handle_t *id, int cmd,
102 envmon_keysw_pos_t *key_state);
103 static void convert_node_name(char *ptr);
104 static void convert_label_name(char *ptr);
105 static int add_value_prop(picl_nodehdl_t node_hdl, const char *prop_name,
106 int fru_type, int16_t value);
107 static int find_picl_handle(picl_prophdl_t proph);
108 static int lookup_led_status(int8_t state, const char **string);
109 static int lookup_key_posn(envmon_keysw_pos_t pos, const char **string);
110 static int get_config_file(char *filename);
111 static int read_vol_data(ptree_rarg_t *r_arg, void *buf);
112 static int write_led_data(ptree_warg_t *w_arg, const void *buf);
113 static int add_env_nodes(int envmon_fd, uint8_t fru_type,
114 picl_nodehdl_t envmonh);
115 static void fixstate(uint8_t state, const char *string, int *max_len);
116 static void fixkeyposn(envmon_keysw_pos_t keyposn, const char *string,
117 int *max_len);
118 static void setup_strings();
119 static void free_vol_prop(picl_prophdl_t proph);
120 static void envmon_evhandler(const char *ename, const void *earg,
121 size_t size, void *cookie);
122 static int get_serial_num(int envmon_fd, envmon_handle_t *id, int cmd,
123 envmon_chassis_t *chassis);
124
125 #pragma init(piclenvmon_register)
126
127 static picld_plugin_reg_t my_reg_info = {
128 PICLD_PLUGIN_VERSION_1,
129 PICLD_PLUGIN_NON_CRITICAL,
130 "SUNW_piclenvmon",
131 piclenvmon_init,
132 piclenvmon_fini
133 };
134
135 static const char str_On[] = "on";
136 static const char str_Off[] = "off";
137 static const char str_Blinking[] = "blinking";
138 static const char str_Flashing[] = "flashing";
139 static const char str_SC[] = "SC";
140 static char *envmon_device_name = NULL;
141 static envmon_sysinfo_t env_limits;
142 static handle_array_t handle_arr;
143 static struct {
144 int size;
145 char *str_colour;
146 } colour_lkup[1 + ENVMON_LED_CLR_RED];
147
148 static struct {
149 int8_t state;
150 char *str_ledstate;
151 } ledstate_lkup[] = {
152 { ENVMON_LED_OFF },
153 { ENVMON_LED_ON },
154 { ENVMON_LED_BLINKING },
155 { ENVMON_LED_FLASHING }
156 };
157
158 static struct {
159 envmon_keysw_pos_t pos;
160 char *str_keyposn;
161 } keyposn_lkup[] = {
162 { ENVMON_KEYSW_POS_UNKNOWN },
163 { ENVMON_KEYSW_POS_NORMAL },
164 { ENVMON_KEYSW_POS_DIAG },
165 { ENVMON_KEYSW_POS_LOCKED },
166 { ENVMON_KEYSW_POS_OFF }
167 };
168
169 /*
170 * fru-type to ioctl cmd lookup
171 */
172 int fru_to_cmd[] = {
173 ENVMONIOCVOLTSENSOR,
174 ENVMONIOCVOLTIND,
175 ENVMONIOCAMPSENSOR,
176 ENVMONIOCAMPIND,
177 ENVMONIOCTEMPSENSOR,
178 ENVMONIOCTEMPIND,
179 ENVMONIOCFAN,
180 ENVMONIOCFANIND,
181 ENVMONIOCGETLED,
182 ENVMONIOCGETKEYSW,
183 ENVMONIOCCHASSISSERIALNUM
184 };
185
186 /*
187 * fru-type to PICL CLASS
188 */
189 const char *fru_to_class[] = {
190 PICL_CLASS_VOLTAGE_SENSOR,
191 PICL_CLASS_VOLTAGE_INDICATOR,
192 PICL_CLASS_CURRENT_SENSOR,
193 PICL_CLASS_CURRENT_INDICATOR,
194 PICL_CLASS_TEMPERATURE_SENSOR,
195 PICL_CLASS_TEMPERATURE_INDICATOR,
196 PICL_CLASS_FAN,
197 PICL_CLASS_FAN,
198 PICL_CLASS_LED,
199 PICL_CLASS_KEYSWITCH,
200 PICL_CLASS_CHASSIS_SERIAL_NUM
201 };
202
203 /*
204 * fru-type to PICL PROPERTY for volatile data
205 */
206 const char *fru_to_prop[] = {
207 PICL_PROP_VOLTAGE,
208 PICL_PROP_CONDITION,
209 PICL_PROP_CURRENT,
210 PICL_PROP_CONDITION,
211 PICL_PROP_TEMPERATURE,
212 PICL_PROP_CONDITION,
213 PICL_PROP_FAN_SPEED,
214 PICL_PROP_FAN_SPEED_UNIT,
215 PICL_PROP_STATE,
216 PICL_PROP_STATE,
217 PICL_PROP_SERIAL_NUMBER
218 };
219
220 /*
221 * fru-type to PICL PTYPE
222 */
223 int fru_to_ptype[] = {
224 PICL_PTYPE_FLOAT,
225 PICL_PTYPE_CHARSTRING,
226 PICL_PTYPE_FLOAT,
227 PICL_PTYPE_CHARSTRING,
228 PICL_PTYPE_INT,
229 PICL_PTYPE_CHARSTRING,
230 PICL_PTYPE_UNSIGNED_INT,
231 PICL_PTYPE_CHARSTRING,
232 PICL_PTYPE_CHARSTRING,
233 PICL_PTYPE_CHARSTRING,
234 PICL_PTYPE_CHARSTRING
235 };
236
237 /*
238 * condition strings
239 */
240 static char *cond_okay;
241 static char *cond_failed;
242
243 /*
244 * fru-type to size of volatile property
245 * the -1's are replaced by the max size of a condition string
246 */
247 int fru_to_size[] = {
248 4, -1, 4, -1, 2, -1, 2, -1, -1, -1, -1
249 };
250
251 static node_el_t *
252 create_node_el(picl_nodehdl_t nodeh)
253 {
254 node_el_t *ptr = malloc(sizeof (node_el_t));
255
256 if (ptr != NULL) {
257 ptr->nodeh = nodeh;
258 ptr->next = NULL;
259 }
260
261 return (ptr);
262 }
263
264 static void
265 delete_node_el(node_el_t *pel)
266 {
267 free(pel);
268 }
269
270 static node_list_t *
271 create_node_list()
272 {
273 node_list_t *ptr = malloc(sizeof (node_list_t));
274
275 if (ptr != NULL) {
276 ptr->head = NULL;
277 ptr->tail = NULL;
278 }
279
280 return (ptr);
281 }
282
283 static void
284 delete_node_list(node_list_t *pnl)
285 {
286 node_el_t *pel;
287
288 if (pnl == NULL)
289 return;
290
291 while ((pel = pnl->head) != NULL) {
292 pnl->head = pel->next;
293 delete_node_el(pel);
294 }
295
296 /*
297 * normally pnl->tail would be to NULL next,
298 * but as it is about to be freed, this step can be skipped.
299 */
300 free(pnl);
301 }
302
303 /*
304 * Get a linking element and add handle to end of chain
305 */
306 static void
307 add_node_to_list(picl_nodehdl_t nodeh, node_list_t *listp)
308 {
309 node_el_t *pel = create_node_el(nodeh);
310
311 if (pel != NULL) {
312 if (listp->tail == NULL)
313 listp->head = pel;
314 else
315 listp->tail->next = pel;
316
317 listp->tail = pel;
318 }
319 }
320
321 /*
322 * Get a list of nodes of the specified classname under nodeh.
323 * Once a node of the specified class is found, its children are not
324 * searched.
325 */
326 static void
327 get_node_list_by_class(picl_nodehdl_t nodeh, const char *classname,
328 node_list_t *listp)
329 {
330 int err;
331 char clname[PICL_CLASSNAMELEN_MAX+1];
332 picl_nodehdl_t chdh;
333
334 /*
335 * go through the children
336 */
337 err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
338 sizeof (picl_nodehdl_t));
339
340 while (err == PICL_SUCCESS) {
341 err = ptree_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
342 clname, strlen(classname) + 1);
343
344 if ((err == PICL_SUCCESS) && (strcmp(clname, classname) == 0))
345 add_node_to_list(chdh, listp);
346 else
347 get_node_list_by_class(chdh, classname, listp);
348
349 err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
350 sizeof (picl_nodehdl_t));
351 }
352 }
353
354 static int
355 get_envmon_limits(int envmon_fd, envmon_sysinfo_t *limits_p)
356 {
357 return (ioctl(envmon_fd, ENVMONIOCSYSINFO, limits_p));
358 }
359
360 static int
361 re_create_arrays(int envmon_fd)
362 {
363 envmon_sysinfo_t new_limits;
364 int res;
365 int maxnum;
366 uchar_t *fru_types;
367 envmon_handle_t *envhandles;
368 picl_prophdl_t *piclprhdls;
369
370 res = get_envmon_limits(envmon_fd, &new_limits);
371 if (res != 0)
372 return (res);
373
374 maxnum = new_limits.maxVoltSens + new_limits.maxVoltInd +
375 new_limits.maxAmpSens + new_limits.maxAmpInd +
376 new_limits.maxTempSens + new_limits.maxTempInd +
377 new_limits.maxFanSens + new_limits.maxFanInd +
378 new_limits.maxLED + N_KEY_SWITCHES;
379
380 if (maxnum != handle_arr.maxnum) {
381 /*
382 * space requirements have changed
383 */
384 fru_types = calloc(maxnum, sizeof (uchar_t));
385 envhandles = calloc(maxnum, sizeof (envmon_handle_t));
386 piclprhdls = calloc(maxnum, sizeof (picl_prophdl_t));
387 if ((fru_types == NULL) || (envhandles == NULL) ||
388 (piclprhdls == NULL)) {
389 free(fru_types);
390 free(envhandles);
391 free(piclprhdls);
392 return (-1);
393 }
394 free(handle_arr.fru_types);
395 handle_arr.fru_types = fru_types;
396 free(handle_arr.envhandles);
397 handle_arr.envhandles = envhandles;
398 free(handle_arr.piclprhdls);
399 handle_arr.piclprhdls = piclprhdls;
400 } else {
401 (void) memset(handle_arr.fru_types, 0,
402 maxnum * sizeof (uchar_t));
403 (void) memset(handle_arr.envhandles, 0,
404 maxnum * sizeof (envmon_handle_t));
405 (void) memset(handle_arr.piclprhdls, 0,
406 maxnum * sizeof (picl_prophdl_t));
407 }
408
409 handle_arr.num = 0;
410 handle_arr.maxnum = maxnum;
411 env_limits = new_limits;
412 return (0);
413 }
414
415 static void
416 create_arrays()
417 {
418 int maxnum = env_limits.maxVoltSens + env_limits.maxVoltInd +
419 env_limits.maxAmpSens + env_limits.maxAmpInd +
420 env_limits.maxTempSens + env_limits.maxTempInd +
421 env_limits.maxFanSens + env_limits.maxFanInd +
422 env_limits.maxLED + N_KEY_SWITCHES;
423 handle_arr.maxnum = maxnum;
424 handle_arr.num = 0;
425 handle_arr.fru_types = calloc(maxnum, sizeof (uchar_t));
426 handle_arr.envhandles = calloc(maxnum, sizeof (envmon_handle_t));
427 handle_arr.piclprhdls = calloc(maxnum, sizeof (picl_prophdl_t));
428 }
429
430 static int
431 get_envmon_node(picl_nodehdl_t *envmoninfh)
432 {
433 int err = PICL_SUCCESS;
434 node_list_t *listp;
435
436 listp = create_node_list();
437
438 if ((err = ptree_get_node_by_path(PICL_NODE_ROOT PICL_NODE_PLATFORM,
439 envmoninfh)) != PICL_SUCCESS) {
440 syslog(LOG_ERR, EM_MISSING_NODE,
441 PICL_NODE_ROOT PICL_NODE_PLATFORM);
442 return (err); /* no /platform ! */
443 }
444
445 get_node_list_by_class(*envmoninfh, PICL_CLASS_SERVICE_PROCESSOR,
446 listp);
447
448 if (listp->head == NULL) {
449 *envmoninfh = 0;
450 syslog(LOG_ERR, EM_MISSING_NODE, PICL_CLASS_SERVICE_PROCESSOR);
451 err = PICL_NODENOTFOUND;
452 } else {
453 *envmoninfh = listp->head->nodeh;
454 }
455
456 delete_node_list(listp);
457 return (err);
458 }
459
460 static char *
461 create_envmon_pathname(picl_nodehdl_t envmoninfh)
462 {
463 char *ptr;
464 char namebuf[PATH_MAX];
465 size_t len;
466 DIR *dirp;
467 struct dirent *dp;
468 struct stat statbuf;
469
470 /* prefix devfs-path name with /devices */
471 (void) strlcpy(namebuf, "/devices", PATH_MAX);
472
473 /*
474 * append devfs-path property
475 */
476 len = strlen(namebuf);
477 if (ptree_get_propval_by_name(envmoninfh, PICL_PROP_DEVFS_PATH,
478 namebuf + len, sizeof (namebuf) - len) != PICL_SUCCESS) {
479 syslog(LOG_ERR, EM_SC_NODE_INCOMPLETE);
480 return (NULL);
481 }
482
483 /* locate final component of name */
484 ptr = strrchr(namebuf, '/');
485 if (ptr == NULL)
486 return (NULL);
487 *ptr = '\0'; /* terminate at end of directory path */
488 len = strlen(ptr + 1); /* length of terminal name */
489 dirp = opendir(namebuf);
490 if (dirp == NULL) {
491 syslog(LOG_ERR, EM_SC_NODE_MISSING);
492 return (NULL);
493 }
494 *ptr++ = '/'; /* restore '/' and advance to final name */
495
496 while ((dp = readdir(dirp)) != NULL) {
497 /*
498 * look for a name which starts with the string at *ptr
499 */
500 if (strlen(dp->d_name) < len)
501 continue; /* skip short names */
502 if (strncmp(dp->d_name, ptr, len) == 0) {
503 /*
504 * Got a match, restore full pathname and stat the
505 * entry. Reject if not a char device
506 */
507 (void) strlcpy(ptr, dp->d_name,
508 sizeof (namebuf) - (ptr - namebuf));
509 if (stat(namebuf, &statbuf) < 0)
510 continue; /* reject if can't stat it */
511 if (!S_ISCHR(statbuf.st_mode))
512 continue; /* not a character device */
513 /*
514 * go with this entry
515 */
516 (void) closedir(dirp);
517 return (strdup(namebuf));
518 }
519 }
520 syslog(LOG_ERR, EM_SC_NODE_MISSING);
521 (void) closedir(dirp);
522 return (NULL);
523 }
524
525 /*
526 * look for named node as child of supplied handle
527 */
528 static int
529 get_child_by_name(picl_nodehdl_t nodeh, const char *name,
530 picl_nodehdl_t *childh)
531 {
532 int err;
533 char node_name[ENVMON_MAXNAMELEN];
534
535 if (strlen(name) >= ENVMON_MAXNAMELEN)
536 return (PICL_NODENOTFOUND);
537 err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, childh,
538 sizeof (*childh));
539 while (err == PICL_SUCCESS) {
540 err = ptree_get_propval_by_name(*childh, PICL_PROP_NAME,
541 node_name, sizeof (node_name));
542 if ((err == PICL_SUCCESS) &&
543 (strncmp(name, node_name, ENVMON_MAXNAMELEN) == 0))
544 return (PICL_SUCCESS);
545 err = ptree_get_propval_by_name(*childh, PICL_PROP_PEER,
546 childh, sizeof (*childh));
547 }
548 return (err);
549 }
550
551 /*
552 * Create and add the specified regular property
553 */
554 static int
555 add_regular_prop(picl_nodehdl_t nodeh, const char *name, int type, int access,
556 int size, const void *valbuf, picl_prophdl_t *prophp)
557 {
558 int err;
559 ptree_propinfo_t propinfo;
560 picl_prophdl_t proph;
561
562 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
563 type, access, size, (char *)name, NULL, NULL);
564 if (err != PICL_SUCCESS)
565 return (err);
566
567 err = ptree_create_and_add_prop(nodeh, &propinfo, (void *)valbuf,
568 &proph);
569 if (err == PICL_SUCCESS && prophp)
570 *prophp = proph;
571 return (err);
572 }
573
574
575 /*
576 * Create and add the specified volatile property
577 */
578 static int
579 add_volatile_prop(picl_nodehdl_t nodeh, const char *name, int type, int access,
580 int size, ptree_vol_rdfunc_t rdfunc, ptree_vol_wrfunc_t wrfunc,
581 picl_prophdl_t *prophp)
582 {
583 int err;
584 ptree_propinfo_t propinfo;
585 picl_prophdl_t proph;
586
587 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
588 type, (access|PICL_VOLATILE), size, (char *)name, rdfunc, wrfunc);
589 if (err != PICL_SUCCESS)
590 return (err);
591
592 err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph);
593 if (err == PICL_SUCCESS && prophp)
594 *prophp = proph;
595 return (err);
596 }
597
598 /*
599 * There are 5 different structures used for reading environmental data
600 * from the service-processor. A different function is used for each one.
601 * Some functions cover several ioctls, so the desired ioctl is part of
602 * the interface. In each case the id parameter is read/write, the
603 * returned value being the next id for this fru type.
604 */
605
606 /*
607 * Function to read sensor data.
608 */
609 static int
610 get_sensor_data(int envmon_fd, envmon_handle_t *id, int cmd,
611 envmon_thresholds_t *lows, envmon_thresholds_t *highs, int16_t *value)
612 {
613 int res;
614 envmon_sensor_t data;
615
616 (void) memset(&data, 0, sizeof (data));
617 data.id = *id;
618 res = ioctl(envmon_fd, cmd, &data);
619 if (res < 0) {
620 return (PICL_NOTREADABLE);
621 }
622
623 *id = data.next_id;
624
625 if ((data.sensor_status & ENVMON_NOT_PRESENT) != 0)
626 return (PICL_INVALIDHANDLE);
627
628 /*
629 * it is assumed that threshold data will be available,
630 * even though the current sensor value may be inaccessible
631 */
632 if (lows != NULL)
633 *lows = data.lowthresholds;
634 if (highs != NULL)
635 *highs = data.highthresholds;
636
637 if ((data.sensor_status & ENVMON_INACCESSIBLE) != 0) {
638 if (value != NULL)
639 *value = ENVMON_VAL_UNAVAILABLE;
640 return (PICL_PROPVALUNAVAILABLE);
641 }
642 if (value != NULL)
643 *value = data.value;
644 return (PICL_SUCCESS);
645 }
646
647 /*
648 * Function to read indicator data.
649 */
650 static int
651 get_indicator_data(int envmon_fd, envmon_handle_t *id, int cmd,
652 int16_t *condition)
653 {
654 int res;
655 envmon_indicator_t data;
656
657 data.id = *id;
658 res = ioctl(envmon_fd, cmd, &data);
659 if (res < 0)
660 return (PICL_NOTREADABLE);
661 *id = data.next_id;
662 if ((data.sensor_status & ENVMON_NOT_PRESENT) != 0)
663 return (PICL_INVALIDHANDLE);
664 if (condition != NULL)
665 *condition = data.condition;
666 if ((data.sensor_status & ENVMON_INACCESSIBLE) != 0) {
667 return (PICL_PROPVALUNAVAILABLE);
668 }
669 return (PICL_SUCCESS);
670 }
671
672 /*
673 * Function to read fan data.
674 */
675 static int
676 get_fan_data(int envmon_fd, envmon_handle_t *id, int cmd,
677 envmon_thresholds_t *lows, uint16_t *speed, char *units)
678 {
679 int res;
680 envmon_fan_t data;
681
682 data.id = *id;
683 res = ioctl(envmon_fd, cmd, &data);
684 if (res < 0)
685 return (PICL_NOTREADABLE);
686 *id = data.next_id;
687 if ((data.sensor_status & ENVMON_NOT_PRESENT) != 0)
688 return (PICL_INVALIDHANDLE);
689 if (lows != NULL)
690 *lows = data.lowthresholds;
691 if (units != NULL)
692 (void) strlcpy(units, data.units, sizeof (data.units));
693
694 if ((data.sensor_status & ENVMON_INACCESSIBLE) != 0) {
695 if (speed != NULL)
696 *speed = ENVMON_VAL_UNAVAILABLE;
697 return (PICL_PROPVALUNAVAILABLE);
698 }
699 if (speed != NULL)
700 *speed = data.speed;
701 return (PICL_SUCCESS);
702 }
703
704 /*
705 * Function to read LED data.
706 */
707 static int
708 get_led_data(int envmon_fd, envmon_handle_t *id, int cmd,
709 int8_t *state, int8_t *colour)
710 {
711 int res;
712 envmon_led_info_t data;
713
714 data.id = *id;
715 res = ioctl(envmon_fd, cmd, &data);
716 if (res < 0)
717 return (PICL_NOTREADABLE);
718 *id = data.next_id;
719 if ((data.sensor_status & ENVMON_NOT_PRESENT) != 0)
720 return (PICL_INVALIDHANDLE);
721 if (colour != NULL)
722 *colour = data.led_color;
723 if ((data.sensor_status & ENVMON_INACCESSIBLE) != 0) {
724 return (PICL_PROPVALUNAVAILABLE);
725 }
726 if (state != NULL)
727 *state = data.led_state;
728 return (PICL_SUCCESS);
729 }
730
731 /*
732 * Function to read key-switch position
733 * Returns PICL_INVALIDHANDLE if ioctl not supported (or fails)
734 */
735 static int
736 get_keyswitch_data(int envmon_fd, envmon_handle_t *id, int cmd,
737 envmon_keysw_pos_t *key_state)
738 {
739 int res;
740
741 if (id->name[0] == '\0') {
742 (void) strlcpy(id->name, KEYSWITCH_NAME, sizeof (id->name));
743 return (PICL_INVALIDHANDLE);
744 } else if (strncmp(id->name, KEYSWITCH_NAME, sizeof (id->name)) != 0) {
745 id->name[0] = '\0';
746 return (PICL_INVALIDHANDLE);
747 } else {
748 res = ioctl(envmon_fd, cmd, key_state);
749 id->name[0] = '\0';
750
751 if (res < 0)
752 return (PICL_INVALIDHANDLE);
753 return (PICL_SUCCESS);
754 }
755 }
756
757 /*
758 * Function to read the chassis serial number
759 * Returns PICL_INVALIDHANDLE if ioctl not supported (or fails)
760 */
761 static int
762 get_serial_num(int envmon_fd, envmon_handle_t *id, int cmd,
763 envmon_chassis_t *chassis)
764 {
765 int res;
766
767 if (id->name[0] == '\0') {
768 (void) strlcpy(id->name, CHASSIS_SERIAL_NUMBER,
769 sizeof (id->name));
770 return (PICL_INVALIDHANDLE);
771 } else if (strncmp(id->name, CHASSIS_SERIAL_NUMBER, sizeof (id->name))
772 != 0) {
773 id->name[0] = '\0';
774 return (PICL_INVALIDHANDLE);
775 } else {
776 res = ioctl(envmon_fd, cmd, chassis);
777 id->name[0] = '\0';
778
779 if (res < 0)
780 return (PICL_INVALIDHANDLE);
781 return (PICL_SUCCESS);
782 }
783 }
784
785 /*
786 * change to lower case and convert any spaces into hyphens,
787 * and any dots or colons symbols into underscores
788 */
789 static void
790 convert_node_name(char *ptr)
791 {
792 char ch;
793
794 for (ch = *ptr; ch != '\0'; ch = *++ptr) {
795 if (isupper(ch)) {
796 *ptr = tolower(ch);
797 } else if (isspace(ch)) {
798 *ptr = '-';
799 } else if ((ch == '.') || (ch == ':')) {
800 *ptr = '_';
801 }
802 }
803 }
804
805 /*
806 * strip to the last '.' separator and keep the rest
807 * change ':' to '/' within the last component
808 */
809 static void
810 convert_label_name(char *name)
811 {
812 const char *cptr;
813 char ch;
814
815 cptr = strrchr(name, '.');
816
817 if (cptr == NULL)
818 cptr = name;
819 else
820 cptr++; /* skip the '.' */
821
822 do {
823 ch = *cptr++;
824
825 if (ch == ':')
826 ch = '/';
827
828 *name++ = ch;
829 } while (ch != '\0');
830 }
831
832 /*
833 * add a value property
834 */
835 static int
836 add_value_prop(picl_nodehdl_t node_hdl, const char *prop_name, int fru_type,
837 int16_t value)
838 {
839 int err;
840 union {
841 float u_f;
842 int16_t u_i16;
843 } val_buf;
844
845 if (fru_to_ptype[fru_type] == PICL_PTYPE_FLOAT)
846 val_buf.u_f = (float)((float)value / (float)1000.0);
847 else
848 val_buf.u_i16 = value;
849
850 err = add_regular_prop(node_hdl, prop_name, fru_to_ptype[fru_type],
851 PICL_READ, fru_to_size[fru_type], &val_buf, NULL);
852 return (err);
853 }
854
855 static int
856 find_picl_handle(picl_prophdl_t proph)
857 {
858 int index;
859
860 for (index = 0; index < handle_arr.num; index++) {
861 if (handle_arr.piclprhdls[index] == proph)
862 return (index);
863 }
864
865 return (-1);
866 }
867
868 /*
869 * look up function to convert led status into string
870 */
871 static int
872 lookup_led_status(int8_t state, const char **string)
873 {
874 int i;
875 int lim = sizeof (ledstate_lkup) / sizeof (ledstate_lkup[0]);
876
877 for (i = 0; i < lim; i++) {
878 if (ledstate_lkup[i].state == state) {
879 *string = ledstate_lkup[i].str_ledstate;
880 return (PICL_SUCCESS);
881 }
882 }
883
884 *string = "";
885 return (PICL_PROPVALUNAVAILABLE);
886 }
887
888 static int
889 lookup_key_posn(envmon_keysw_pos_t pos, const char **string)
890 {
891 int i;
892 int lim = sizeof (keyposn_lkup) / sizeof (keyposn_lkup[0]);
893
894 for (i = 0; i < lim; i++) {
895 if (keyposn_lkup[i].pos == pos) {
896 *string = keyposn_lkup[i].str_keyposn;
897 return (PICL_SUCCESS);
898 }
899 }
900
901 *string = "";
902 return (PICL_PROPVALUNAVAILABLE);
903 }
904
905 /*
906 * function to read volatile data associated with a PICL property handle
907 */
908 static int
909 read_vol_data(ptree_rarg_t *r_arg, void *buf)
910 {
911 picl_prophdl_t proph;
912 int index;
913 uint8_t fru_type;
914 envmon_handle_t id;
915 int16_t sensor_data;
916 int8_t led_state;
917 envmon_keysw_pos_t key_posn;
918 envmon_chassis_t chassis;
919 float float_data;
920 int cmd;
921 int err;
922 int envmon_fd;
923 const char *cptr;
924
925 proph = r_arg->proph;
926 index = find_picl_handle(proph);
927 if (index < 0)
928 return (PICL_INVALIDHANDLE);
929 fru_type = handle_arr.fru_types[index];
930 id = handle_arr.envhandles[index];
931 cmd = fru_to_cmd[fru_type];
932 envmon_fd = open(envmon_device_name, O_RDONLY);
933 if (envmon_fd < 0)
934 return (PICL_NOTREADABLE);
935
936 /*
937 * read environmental data according to type
938 */
939 switch (fru_type) {
940 case ENVMON_VOLT_SENS:
941 /*FALLTHROUGH*/
942 case ENVMON_AMP_SENS:
943 /*FALLTHROUGH*/
944 case ENVMON_TEMP_SENS:
945 err = get_sensor_data(envmon_fd, &id, cmd, NULL, NULL,
946 &sensor_data);
947 break;
948 case ENVMON_VOLT_IND:
949 /*FALLTHROUGH*/
950 case ENVMON_AMP_IND:
951 /*FALLTHROUGH*/
952 case ENVMON_TEMP_IND:
953 /*FALLTHROUGH*/
954 case ENVMON_FAN_IND:
955 err = get_indicator_data(envmon_fd, &id, cmd, &sensor_data);
956 break;
957 case ENVMON_FAN_SENS:
958 err = get_fan_data(envmon_fd, &id, cmd, NULL,
959 (uint16_t *)&sensor_data, NULL);
960 break;
961 case ENVMON_LED_IND:
962 err = get_led_data(envmon_fd, &id, cmd, &led_state, NULL);
963 break;
964 case ENVMON_KEY_SWITCH:
965 err = get_keyswitch_data(envmon_fd, &id, cmd, &key_posn);
966 break;
967 case ENVMON_CHASSIS:
968 err = get_serial_num(envmon_fd, &id, cmd, &chassis);
969 break;
970 default:
971 err = PICL_FAILURE;
972 break;
973 }
974
975 (void) close(envmon_fd);
976 if (err != PICL_SUCCESS) {
977 /*
978 * PICL_INVALIDHANDLE is used internally, but it upsets
979 * prtpicl; change it to PICL_PROPVALUNAVAILABLE
980 */
981 if (err == PICL_INVALIDHANDLE)
982 err = PICL_PROPVALUNAVAILABLE;
983 return (err);
984 }
985
986 /*
987 * convert data and copy out
988 */
989 switch (fru_type) {
990 case ENVMON_VOLT_SENS:
991 /*FALLTHROUGH*/
992 case ENVMON_AMP_SENS:
993 float_data = (float)((float)sensor_data / (float)1000.0);
994 (void) memcpy(buf, &float_data, sizeof (float_data));
995 break;
996
997 case ENVMON_TEMP_SENS:
998 /*FALLTHROUGH*/
999 case ENVMON_FAN_SENS:
1000 (void) memcpy(buf, &sensor_data, sizeof (sensor_data));
1001 break;
1002
1003 case ENVMON_VOLT_IND:
1004 /*FALLTHROUGH*/
1005 case ENVMON_AMP_IND:
1006 /*FALLTHROUGH*/
1007 case ENVMON_TEMP_IND:
1008 /*FALLTHROUGH*/
1009 case ENVMON_FAN_IND:
1010 (void) strlcpy(buf, sensor_data == 0 ? cond_okay : cond_failed,
1011 fru_to_size[fru_type]);
1012 break;
1013
1014 case ENVMON_LED_IND:
1015 err = lookup_led_status(led_state, &cptr);
1016 if (err != PICL_SUCCESS)
1017 return (err);
1018 (void) strlcpy(buf, cptr, fru_to_size[fru_type]);
1019 break;
1020
1021 case ENVMON_KEY_SWITCH:
1022 err = lookup_key_posn(key_posn, &cptr);
1023 if (err != PICL_SUCCESS)
1024 return (err);
1025 (void) strlcpy(buf, cptr, fru_to_size[fru_type]);
1026 break;
1027 case ENVMON_CHASSIS:
1028 (void) memcpy(buf, chassis.serial_number,
1029 sizeof (chassis.serial_number));
1030 break;
1031
1032 default:
1033 return (PICL_FAILURE);
1034 }
1035
1036 return (PICL_SUCCESS);
1037 }
1038
1039 static int
1040 write_led_data(ptree_warg_t *w_arg, const void *buf)
1041 {
1042 picl_prophdl_t proph;
1043 int index;
1044 uint8_t fru_type;
1045 int err;
1046 int envmon_fd;
1047 envmon_led_ctl_t led_ctl;
1048
1049 proph = w_arg->proph;
1050 index = find_picl_handle(proph);
1051 if (index < 0)
1052 return (PICL_INVALIDHANDLE);
1053 fru_type = handle_arr.fru_types[index];
1054 if (fru_type != ENVMON_LED_IND)
1055 return (PICL_INVALIDARG);
1056 if (w_arg->cred.dc_euid != SUPER_USER)
1057 return (PICL_PERMDENIED);
1058
1059 /* see if the requested state is recognized */
1060 if (strcasecmp(str_Off, buf) == 0)
1061 led_ctl.led_state = ENVMON_LED_OFF;
1062 else if (strcasecmp(str_On, buf) == 0)
1063 led_ctl.led_state = ENVMON_LED_ON;
1064 else if (strcasecmp(str_Blinking, buf) == 0)
1065 led_ctl.led_state = ENVMON_LED_BLINKING;
1066 else if (strcasecmp(str_Flashing, buf) == 0)
1067 led_ctl.led_state = ENVMON_LED_FLASHING;
1068 else
1069 return (PICL_INVALIDARG);
1070
1071 envmon_fd = open(envmon_device_name, O_RDWR);
1072 if (envmon_fd < 0)
1073 return (PICL_FAILURE);
1074 led_ctl.id = handle_arr.envhandles[index];
1075 err = ioctl(envmon_fd, ENVMONIOCSETLED, &led_ctl);
1076 (void) close(envmon_fd);
1077 if (err < 0)
1078 return (PICL_FAILURE);
1079 return (PICL_SUCCESS);
1080 }
1081
1082 /*
1083 * if colour information is not supplied by the service processor,
1084 * try to determine led colour from the handle name.
1085 */
1086 static void
1087 fix_led_colour(int8_t *colour_p, const char *id)
1088 {
1089 const char *cptr = strrchr(id, '.');
1090
1091 if ((*colour_p < ENVMON_LED_CLR_NONE) ||
1092 (*colour_p > ENVMON_LED_CLR_RED))
1093 syslog(LOG_ERR, EM_INVALID_COLOR, *colour_p, id);
1094 if (cptr == NULL) {
1095 *colour_p = ENVMON_LED_CLR_NONE;
1096 return;
1097 }
1098
1099 cptr++; /* step over '.' */
1100
1101 if (strcmp(cptr, LED_ACT) == 0)
1102 *colour_p = ENVMON_LED_CLR_GREEN;
1103 else if (strcmp(cptr, LED_SERVICE) == 0)
1104 *colour_p = ENVMON_LED_CLR_AMBER;
1105 else if (strcmp(cptr, LED_LOCATE) == 0)
1106 *colour_p = ENVMON_LED_CLR_WHITE;
1107 else if (strcmp(cptr, LED_OK2RM) == 0)
1108 *colour_p = ENVMON_LED_CLR_BLUE;
1109 else
1110 *colour_p = ENVMON_LED_CLR_NONE;
1111 }
1112
1113 /*
1114 * Add nodes for environmental devices of type fru_type
1115 * below the supplied node.
1116 */
1117 static int
1118 add_env_nodes(int envmon_fd, uint8_t fru_type, picl_nodehdl_t envmonh)
1119 {
1120 envmon_handle_t id;
1121 envmon_thresholds_t lows;
1122 envmon_thresholds_t highs;
1123 char units[ENVMON_MAXNAMELEN];
1124 char platform_tree_name[ENVMON_MAXNAMELEN];
1125 char label_name[ENVMON_MAXNAMELEN];
1126 int16_t sensor_data;
1127 int8_t led_state;
1128 int8_t colour;
1129 envmon_keysw_pos_t key_state;
1130 envmon_chassis_t chassis_num;
1131 int cmd;
1132 int err;
1133 int index = handle_arr.num;
1134 picl_nodehdl_t node_hdl;
1135
1136 /*
1137 * catch table is full at start
1138 */
1139 if (index >= handle_arr.maxnum)
1140 return (PICL_FAILURE);
1141
1142 cmd = fru_to_cmd[fru_type];
1143 id.name[0] = '\0';
1144
1145 do {
1146 lows.warning = lows.shutdown = lows.poweroff =
1147 ENVMON_VAL_UNAVAILABLE;
1148 highs.warning = highs.shutdown = highs.poweroff =
1149 ENVMON_VAL_UNAVAILABLE;
1150 handle_arr.fru_types[index] = fru_type;
1151 /* must store id before reading data as it is then updated */
1152 handle_arr.envhandles[index] = id;
1153 /*
1154 * read environmental data according to type
1155 */
1156 switch (fru_type) {
1157 case ENVMON_VOLT_SENS:
1158 /*FALLTHROUGH*/
1159 case ENVMON_AMP_SENS:
1160 /*FALLTHROUGH*/
1161 case ENVMON_TEMP_SENS:
1162 err = get_sensor_data(envmon_fd, &id, cmd, &lows,
1163 &highs, &sensor_data);
1164 break;
1165 case ENVMON_VOLT_IND:
1166 /*FALLTHROUGH*/
1167 case ENVMON_AMP_IND:
1168 /*FALLTHROUGH*/
1169 case ENVMON_TEMP_IND:
1170 /*FALLTHROUGH*/
1171 case ENVMON_FAN_IND:
1172 err = get_indicator_data(envmon_fd, &id, cmd,
1173 &sensor_data);
1174 break;
1175 case ENVMON_FAN_SENS:
1176 err = get_fan_data(envmon_fd, &id, cmd, &lows,
1177 (uint16_t *)&sensor_data, units);
1178 break;
1179 case ENVMON_LED_IND:
1180 err = get_led_data(envmon_fd, &id, cmd, &led_state,
1181 &colour);
1182 break;
1183 case ENVMON_KEY_SWITCH:
1184 err = get_keyswitch_data(envmon_fd, &id, cmd,
1185 &key_state);
1186 break;
1187 case ENVMON_CHASSIS:
1188 err = get_serial_num(envmon_fd, &id, cmd,
1189 &chassis_num);
1190 break;
1191 default:
1192 return (PICL_FAILURE);
1193 }
1194
1195 if (err == PICL_INVALIDHANDLE)
1196 continue;
1197 if ((err != PICL_SUCCESS) && (err != PICL_PROPVALUNAVAILABLE)) {
1198 syslog(LOG_ERR, EM_NODE_ACCESS, id, fru_type, err);
1199 continue;
1200 }
1201
1202 /*
1203 * successfully read environmental data, add to PICL
1204 */
1205 (void) strlcpy(platform_tree_name,
1206 handle_arr.envhandles[index].name,
1207 sizeof (platform_tree_name));
1208
1209 (void) strlcpy(label_name, platform_tree_name,
1210 ENVMON_MAXNAMELEN);
1211 convert_label_name(label_name);
1212 convert_node_name(platform_tree_name);
1213 /*
1214 * does this node already exist?
1215 */
1216 err = get_child_by_name(envmonh, platform_tree_name, &node_hdl);
1217 if (err == PICL_SUCCESS) {
1218 /*
1219 * skip over existing node
1220 */
1221 continue;
1222 }
1223 err = ptree_create_node(platform_tree_name,
1224 fru_to_class[fru_type], &node_hdl);
1225 if (err != PICL_SUCCESS) {
1226 break;
1227 }
1228 err = add_volatile_prop(node_hdl, fru_to_prop[fru_type],
1229 fru_to_ptype[fru_type],
1230 PICL_READ | (fru_type == ENVMON_LED_IND ? PICL_WRITE : 0),
1231 fru_to_size[fru_type], read_vol_data,
1232 fru_type == ENVMON_LED_IND ? write_led_data : NULL,
1233 &handle_arr.piclprhdls[index]);
1234 if (err != PICL_SUCCESS) {
1235 break;
1236 }
1237
1238 /*
1239 * if any thresholds are defined add a property
1240 */
1241 if (lows.warning != ENVMON_VAL_UNAVAILABLE) {
1242 err = add_value_prop(node_hdl, PICL_PROP_LOW_WARNING,
1243 fru_type, lows.warning);
1244 if (err != PICL_SUCCESS) {
1245 break;
1246 }
1247 }
1248 if (lows.shutdown != ENVMON_VAL_UNAVAILABLE) {
1249 err = add_value_prop(node_hdl, PICL_PROP_LOW_SHUTDOWN,
1250 fru_type, lows.shutdown);
1251 if (err != PICL_SUCCESS) {
1252 break;
1253 }
1254 }
1255 if (lows.poweroff != ENVMON_VAL_UNAVAILABLE) {
1256 err = add_value_prop(node_hdl, PICL_PROP_LOW_POWER_OFF,
1257 fru_type, lows.poweroff);
1258 if (err != PICL_SUCCESS) {
1259 break;
1260 }
1261 }
1262 if (highs.warning != ENVMON_VAL_UNAVAILABLE) {
1263 err = add_value_prop(node_hdl, PICL_PROP_HIGH_WARNING,
1264 fru_type, highs.warning);
1265 if (err != PICL_SUCCESS) {
1266 break;
1267 }
1268 }
1269 if (highs.shutdown != ENVMON_VAL_UNAVAILABLE) {
1270 err = add_value_prop(node_hdl, PICL_PROP_HIGH_SHUTDOWN,
1271 fru_type, highs.shutdown);
1272 if (err != PICL_SUCCESS) {
1273 break;
1274 }
1275 }
1276 if (highs.poweroff != ENVMON_VAL_UNAVAILABLE) {
1277 err = add_value_prop(node_hdl, PICL_PROP_HIGH_POWER_OFF,
1278 fru_type, highs.poweroff);
1279 if (err != PICL_SUCCESS) {
1280 break;
1281 }
1282 }
1283
1284 /*
1285 * if device is a fan sensor, add a speedunit property
1286 */
1287 if (fru_type == ENVMON_FAN_SENS) {
1288 err = add_regular_prop(node_hdl,
1289 PICL_PROP_FAN_SPEED_UNIT, PICL_PTYPE_CHARSTRING,
1290 PICL_READ, 1 + strlen(units), units, NULL);
1291 if (err != PICL_SUCCESS) {
1292 break;
1293 }
1294 }
1295 /*
1296 * If device is a LED indicator and returns a colour,
1297 * add a colour property.
1298 */
1299 if (fru_type == ENVMON_LED_IND) {
1300 if (colour < 0 || colour == ENVMON_LED_CLR_ANY ||
1301 colour > ENVMON_LED_CLR_RED)
1302 fix_led_colour(&colour,
1303 handle_arr.envhandles[index].name);
1304 if (colour != ENVMON_LED_CLR_NONE) {
1305 err = add_regular_prop(node_hdl,
1306 PICL_PROP_COLOR, PICL_PTYPE_CHARSTRING,
1307 PICL_READ, colour_lkup[colour].size,
1308 colour_lkup[colour].str_colour, NULL);
1309 if (err != PICL_SUCCESS) {
1310 break;
1311 }
1312 }
1313 }
1314 /*
1315 * add a label property unless it's a keyswitch or the
1316 * chassis serial number. keyswitch and chassis serial
1317 * number are labelled from a config file because the
1318 * ALOM interface doesn't supply a name for it)
1319 */
1320 if ((fru_type != ENVMON_KEY_SWITCH) &&
1321 (fru_type != ENVMON_CHASSIS)) {
1322 err = add_regular_prop(node_hdl, PICL_PROP_LABEL,
1323 PICL_PTYPE_CHARSTRING, PICL_READ,
1324 1 + strlen(label_name), label_name, NULL);
1325
1326 if (err != PICL_SUCCESS) {
1327 break;
1328 }
1329 }
1330 /*
1331 * all properties added to this node, add the node below
1332 * the supplied anchor point
1333 */
1334 err = ptree_add_node(envmonh, node_hdl);
1335
1336 if (err != PICL_SUCCESS) {
1337 break;
1338 }
1339
1340 /*
1341 * that node went in OK, advance index
1342 */
1343 index++;
1344
1345 } while ((id.name[0] != '\0') && (index < handle_arr.maxnum));
1346
1347 handle_arr.num = index;
1348 return (err);
1349 }
1350
1351 static void
1352 fixstate(uint8_t state, const char *string, int *max_len)
1353 {
1354 int i;
1355 int len;
1356
1357 for (i = 0; i < (sizeof (ledstate_lkup) / sizeof (ledstate_lkup[0]));
1358 i++) {
1359 if (ledstate_lkup[i].state == state) {
1360 if (ledstate_lkup[i].str_ledstate != NULL)
1361 free(ledstate_lkup[i].str_ledstate);
1362 ledstate_lkup[i].str_ledstate = strdup(string);
1363 len = strlen(string);
1364 if (len >= *max_len)
1365 *max_len = len + 1;
1366 break;
1367 }
1368 }
1369 }
1370
1371 static void
1372 fixkeyposn(envmon_keysw_pos_t keyposn, const char *string, int *max_len)
1373 {
1374 int i;
1375 int len;
1376
1377 for (i = 0; i < (sizeof (keyposn_lkup) / sizeof (keyposn_lkup[0]));
1378 i++) {
1379 if (keyposn_lkup[i].pos == keyposn) {
1380 if (keyposn_lkup[i].str_keyposn != NULL)
1381 free(keyposn_lkup[i].str_keyposn);
1382 keyposn_lkup[i].str_keyposn = strdup(string);
1383 len = strlen(string);
1384 if (len >= *max_len)
1385 *max_len = len + 1;
1386 break;
1387 }
1388 }
1389 }
1390
1391 static void
1392 setup_strings()
1393 {
1394 int string_size;
1395 int i;
1396 int lim = sizeof (colour_lkup) / sizeof (colour_lkup[0]);
1397
1398 /*
1399 * initialise led colours lookup
1400 */
1401 for (i = 0; i < lim; i++) {
1402 if (colour_lkup[i].str_colour != NULL)
1403 free(colour_lkup[i].str_colour);
1404 }
1405
1406 colour_lkup[ENVMON_LED_CLR_ANY].str_colour = strdup(gettext("any"));
1407 colour_lkup[ENVMON_LED_CLR_WHITE].str_colour =
1408 strdup(gettext("white"));
1409 colour_lkup[ENVMON_LED_CLR_BLUE].str_colour = strdup(gettext("blue"));
1410 colour_lkup[ENVMON_LED_CLR_GREEN].str_colour =
1411 strdup(gettext("green"));
1412 colour_lkup[ENVMON_LED_CLR_AMBER].str_colour =
1413 strdup(gettext("amber"));
1414 colour_lkup[ENVMON_LED_CLR_RED].str_colour =
1415 strdup(gettext("red"));
1416
1417 for (i = 0; i < lim; i++) {
1418 if (colour_lkup[i].str_colour != NULL)
1419 colour_lkup[i].size =
1420 1 + strlen(colour_lkup[i].str_colour);
1421 }
1422
1423 /*
1424 * initialise condition strings and note longest
1425 */
1426 string_size = 0;
1427 cond_okay = strdup(gettext("okay"));
1428 if (strlen(cond_okay) >= string_size)
1429 string_size = 1 + strlen(cond_okay);
1430 cond_failed = strdup(gettext("failed"));
1431 if (strlen(cond_failed) >= string_size)
1432 string_size = 1 + strlen(cond_failed);
1433
1434 for (i = 0; i < sizeof (fru_to_size) / sizeof (fru_to_size[0]); i++)
1435 if (fru_to_size[i] == -1)
1436 fru_to_size[i] = string_size;
1437
1438 /*
1439 * initialise led state lookup strings
1440 */
1441 string_size = 0;
1442 fixstate(ENVMON_LED_OFF, gettext("off"), &string_size);
1443 fixstate(ENVMON_LED_ON, gettext("on"), &string_size);
1444 fixstate(ENVMON_LED_BLINKING, gettext("blinking"), &string_size);
1445 fixstate(ENVMON_LED_FLASHING, gettext("flashing"), &string_size);
1446 fru_to_size[ENVMON_LED_IND] = string_size;
1447
1448 /*
1449 * initialise key position lookup strings
1450 */
1451 string_size = 0;
1452 fixkeyposn(ENVMON_KEYSW_POS_UNKNOWN, gettext("UNKNOWN"), &string_size);
1453 fixkeyposn(ENVMON_KEYSW_POS_NORMAL, gettext("NORMAL"), &string_size);
1454 fixkeyposn(ENVMON_KEYSW_POS_DIAG, gettext("DIAG"), &string_size);
1455 fixkeyposn(ENVMON_KEYSW_POS_LOCKED, gettext("LOCKED"), &string_size);
1456 fixkeyposn(ENVMON_KEYSW_POS_OFF, gettext("STBY"), &string_size);
1457 fru_to_size[ENVMON_KEY_SWITCH] = string_size;
1458
1459 /*
1460 * initialise chassis serial number string
1461 */
1462 fru_to_size[ENVMON_CHASSIS] = ENVMON_MAXNAMELEN;
1463 }
1464
1465 /*
1466 * The size of outfilename must be PATH_MAX
1467 */
1468 static int
1469 get_config_file(char *filename)
1470 {
1471 char nmbuf[SYS_NMLN];
1472 char pname[PATH_MAX];
1473
1474 if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
1475 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
1476 (void) strlcat(pname, ENVMON_CONFFILE_NAME, PATH_MAX);
1477 if (access(pname, R_OK) == 0) {
1478 (void) strlcpy(filename, pname, PATH_MAX);
1479 return (0);
1480 }
1481 }
1482
1483 if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
1484 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
1485 (void) strlcat(pname, ENVMON_CONFFILE_NAME, PATH_MAX);
1486 if (access(pname, R_OK) == 0) {
1487 (void) strlcpy(filename, pname, PATH_MAX);
1488 return (0);
1489 }
1490 }
1491
1492 (void) snprintf(pname, PATH_MAX, "%s/%s",
1493 PICLD_COMMON_PLUGIN_DIR, ENVMON_CONFFILE_NAME);
1494
1495 if (access(pname, R_OK) == 0) {
1496 (void) strlcpy(filename, pname, PATH_MAX);
1497 return (0);
1498 }
1499
1500 return (-1);
1501 }
1502
1503 static void
1504 free_vol_prop(picl_prophdl_t proph)
1505 {
1506 int index;
1507
1508 index = find_picl_handle(proph);
1509 if (index >= 0) {
1510 handle_arr.num--;
1511 if (index != handle_arr.num) {
1512 /* relocate last entry into hole just created */
1513 handle_arr.fru_types[index] =
1514 handle_arr.fru_types[handle_arr.num];
1515 handle_arr.envhandles[index] =
1516 handle_arr.envhandles[handle_arr.num];
1517 handle_arr.piclprhdls[index] =
1518 handle_arr.piclprhdls[handle_arr.num];
1519 }
1520 }
1521 }
1522
1523 /*
1524 * handle PICL FRU ADDED and FRU REMOVED events
1525 */
1526 /*ARGSUSED*/
1527 static void
1528 envmon_evhandler(const char *ename, const void *earg, size_t size,
1529 void *cookie)
1530 {
1531 char path[MAXPATHLEN];
1532 picl_nodehdl_t locnodeh;
1533 int retval;
1534 picl_nodehdl_t childh;
1535 picl_nodehdl_t nodeh;
1536 picl_prophdl_t tableh;
1537 picl_prophdl_t tblh;
1538 picl_prophdl_t proph;
1539 ptree_propinfo_t pi;
1540
1541 if (strcmp(ename, PICL_FRU_ADDED) == 0) {
1542 retval = nvlist_lookup_uint64((nvlist_t *)earg,
1543 PICLEVENTARG_PARENTHANDLE, &locnodeh);
1544
1545 if (retval != 0) {
1546 syslog(LOG_ERR, EM_EV_MISSING_ARG,
1547 PICLEVENTARG_PARENTHANDLE);
1548 return;
1549 }
1550 retval = ptree_get_propval_by_name(locnodeh, PICL_PROP_NAME,
1551 path, sizeof (path));
1552 if (retval == PICL_SUCCESS) {
1553 /*
1554 * Open envmon device and interrogate
1555 */
1556 int envmon_fd;
1557 int fru_type;
1558 picl_nodehdl_t envmoninfh;
1559
1560 if (get_envmon_node(&envmoninfh) != PICL_SUCCESS) {
1561 syslog(LOG_ERR, EM_SC_NODE_MISSING);
1562 return;
1563 }
1564
1565 if ((envmon_fd = open(envmon_device_name, O_RDONLY)) <
1566 0) {
1567 syslog(LOG_ERR, EM_SYS_ERR, envmon_device_name,
1568 strerror(errno));
1569 return;
1570 }
1571
1572 if (strcmp(str_SC, path) == 0) {
1573 /*
1574 * SC state change - re-assess platform tree
1575 */
1576 if (re_create_arrays(envmon_fd) != 0) {
1577 /*
1578 * out of memory - make no changes
1579 */
1580 return;
1581 }
1582 /*
1583 * dropped memory of volatile prop handles
1584 * so drop the nodes also, then rebuild for
1585 * the newly loaded SC
1586 */
1587 retval = ptree_get_propval_by_name(envmoninfh,
1588 PICL_PROP_PARENT, &nodeh, sizeof (nodeh));
1589 if (retval != PICL_SUCCESS) {
1590 (void) close(envmon_fd);
1591 return;
1592 }
1593 retval = ptree_get_propval_by_name(envmoninfh,
1594 PICL_PROP_NAME, path, sizeof (path));
1595 if (retval != PICL_SUCCESS) {
1596 (void) close(envmon_fd);
1597 return;
1598 }
1599
1600 retval = ptree_delete_node(envmoninfh);
1601 if (retval == PICL_SUCCESS)
1602 (void) ptree_destroy_node(envmoninfh);
1603 retval = ptree_create_node(path,
1604 PICL_CLASS_SERVICE_PROCESSOR, &envmoninfh);
1605 if (retval != PICL_SUCCESS) {
1606 (void) close(envmon_fd);
1607 return;
1608 }
1609 retval = ptree_add_node(nodeh, envmoninfh);
1610 if (retval != PICL_SUCCESS) {
1611 (void) close(envmon_fd);
1612 return;
1613 }
1614 }
1615
1616 for (fru_type = 0; fru_type < ENVMONTYPES;
1617 fru_type++) {
1618 (void) add_env_nodes(envmon_fd, fru_type,
1619 envmoninfh);
1620 }
1621
1622 (void) close(envmon_fd);
1623 }
1624 } else if (strcmp(ename, PICL_FRU_REMOVED) == 0) {
1625 retval = nvlist_lookup_uint64((nvlist_t *)earg,
1626 PICLEVENTARG_FRUHANDLE, &childh);
1627
1628 if (retval != 0) {
1629 syslog(LOG_ERR, EM_EV_MISSING_ARG,
1630 PICLEVENTARG_FRUHANDLE);
1631 return;
1632 }
1633 retval = ptree_get_propval_by_name(childh, PICL_PROP_NAME,
1634 path, sizeof (path));
1635 if (retval == PICL_SUCCESS) {
1636 retval = ptree_get_prop_by_name(childh,
1637 PICL_PROP_DEVICES, &tableh);
1638
1639 if (retval != PICL_SUCCESS) {
1640 /* no Devices table, nothing to do */
1641 return;
1642 }
1643
1644 /*
1645 * follow all reference properties in the second
1646 * column of the table and delete the referenced node
1647 */
1648 retval = ptree_get_propval(tableh, &tblh,
1649 sizeof (tblh));
1650 if (retval != PICL_SUCCESS) {
1651 /*
1652 * can't get value of table property
1653 */
1654 return;
1655 }
1656 /* get first col, first row */
1657 retval = ptree_get_next_by_col(tblh, &tblh);
1658 if (retval != PICL_SUCCESS) {
1659 /*
1660 * no rows?
1661 */
1662 return;
1663 }
1664 /*
1665 * starting at next col, get every entry in the column
1666 */
1667 for (retval = ptree_get_next_by_row(tblh, &tblh);
1668 retval == PICL_SUCCESS;
1669 retval = ptree_get_next_by_col(tblh, &tblh)) {
1670 /*
1671 * should be a ref prop in our hands,
1672 * get the target node handle
1673 */
1674 retval = ptree_get_propval(tblh, &nodeh,
1675 sizeof (nodeh));
1676 if (retval != PICL_SUCCESS) {
1677 continue;
1678 }
1679 /*
1680 * got the referenced node, has it got a
1681 * volatile property to clean up?
1682 */
1683 retval = ptree_get_first_prop(nodeh, &proph);
1684 while (retval == PICL_SUCCESS) {
1685 retval = ptree_get_propinfo(proph, &pi);
1686 if ((retval == PICL_SUCCESS) &&
1687 (pi.piclinfo.accessmode &
1688 PICL_VOLATILE))
1689 free_vol_prop(proph);
1690 retval = ptree_get_next_prop(proph,
1691 &proph);
1692 }
1693 /*
1694 * all volatile properties gone, remove node
1695 */
1696 retval = ptree_delete_node(nodeh);
1697 if (retval == PICL_SUCCESS)
1698 (void) ptree_destroy_node(nodeh);
1699 }
1700 }
1701 }
1702 }
1703
1704 /*
1705 * executed as part of .init when the plugin is dlopen()ed
1706 */
1707 static void
1708 piclenvmon_register(void)
1709 {
1710 (void) picld_plugin_register(&my_reg_info);
1711 }
1712
1713 /*
1714 * Init entry point of the plugin
1715 * Creates the PICL nodes and properties in the physical and logical aspects.
1716 */
1717 static void
1718 piclenvmon_init(void)
1719 {
1720 picl_nodehdl_t rooth;
1721 picl_nodehdl_t plfh;
1722 picl_nodehdl_t envmoninfh;
1723 int res;
1724 int envmon_fd;
1725 int fru_type;
1726 char pathname[PATH_MAX];
1727
1728 /*
1729 * locate and parse config file
1730 */
1731 if (get_config_file(pathname) < 0)
1732 return;
1733
1734 if ((ptree_get_root(&rooth) != PICL_SUCCESS) ||
1735 (picld_pluginutil_parse_config_file(rooth, pathname) !=
1736 PICL_SUCCESS)) {
1737 syslog(LOG_ERR, EM_INIT_FAILED);
1738 }
1739
1740 /*
1741 * Get platform node
1742 */
1743 if (ptree_get_node_by_path(PICL_NODE_ROOT PICL_NODE_PLATFORM, &plfh)
1744 != PICL_SUCCESS) {
1745 syslog(LOG_ERR, EM_MISSING_NODE, PICL_NODE_PLATFORM);
1746 syslog(LOG_ERR, EM_INIT_FAILED);
1747 return;
1748 }
1749
1750 /*
1751 * Get service-processor node
1752 */
1753 if (get_envmon_node(&envmoninfh) != PICL_SUCCESS)
1754 return;
1755
1756 /*
1757 * We may have been restarted, make sure we don't leak
1758 */
1759 if (envmon_device_name != NULL) {
1760 free(envmon_device_name);
1761 }
1762
1763 if ((envmon_device_name = create_envmon_pathname(envmoninfh)) == NULL)
1764 return;
1765
1766 /*
1767 * Open envmon device and interrogate for devices it monitors
1768 */
1769 if ((envmon_fd = open(envmon_device_name, O_RDONLY)) < 0) {
1770 syslog(LOG_ERR, EM_SYS_ERR, envmon_device_name,
1771 strerror(errno));
1772 return;
1773 }
1774
1775 if (get_envmon_limits(envmon_fd, &env_limits) < 0)
1776 return;
1777
1778 /*
1779 * A set of arrays are used whose bounds are determined by the
1780 * response to get_envmon_limits. Establish these arrays now.
1781 */
1782 create_arrays();
1783 setup_strings();
1784
1785 for (fru_type = 0; fru_type < ENVMONTYPES; fru_type++) {
1786 (void) add_env_nodes(envmon_fd, fru_type, envmoninfh);
1787 }
1788
1789 (void) close(envmon_fd);
1790
1791 res = ptree_register_handler(PICL_FRU_ADDED, envmon_evhandler, NULL);
1792 if (res != PICL_SUCCESS) {
1793 syslog(LOG_ERR, EM_EVREG_FAILED, res);
1794 }
1795 res = ptree_register_handler(PICL_FRU_REMOVED, envmon_evhandler, NULL);
1796 if (res != PICL_SUCCESS) {
1797 syslog(LOG_ERR, EM_EVREG_FAILED, res);
1798 }
1799 }
1800
1801 /*
1802 * fini entry point of the plugin
1803 */
1804 static void
1805 piclenvmon_fini(void)
1806 {
1807 if (envmon_device_name != NULL) {
1808 free(envmon_device_name);
1809 envmon_device_name = NULL;
1810 }
1811 (void) ptree_unregister_handler(PICL_FRU_ADDED,
1812 envmon_evhandler, NULL);
1813 (void) ptree_unregister_handler(PICL_FRU_REMOVED,
1814 envmon_evhandler, NULL);
1815 }
unleashed repo fork