?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / picl / plugins / sun4u / blade / bsc / picllom.c
blob17c6b098af44362d13252133c0a133ece7bb50e4
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 (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * This plugin creates PICL nodes and properties for objects handled through
28 * the blade support chip (BSC). The BSC Solaris land device driver exposes
29 * information to the plugin and other clients through an existing LOM
30 * (Lights Out Management) ioctl interface. The plugin only exercises
31 * a subset of the interface which is known to be supported by the bsc.
32 *
33 * All the nodes which may be accessible through the BSC are included below
34 * the SUNW,bscv node (class system-controller) in the /platform tree.
35 * This plugin interrogates the BSC 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 *
40 * NOTE:
41 * Depends on PICL devtree plugin.
42 */
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <unistd.h>
47 #include <fcntl.h>
48 #include <alloca.h>
49 #include <syslog.h>
50 #include <string.h>
51 #include <libintl.h>
52 #include <picl.h>
53 #include <picltree.h>
54 #include <errno.h>
55 #include <limits.h>
56 #include <ctype.h>
57 #include <sys/types.h>
58 #include <sys/obpdefs.h>
59 #include <sys/lom_io.h>
60 #include <sys/systeminfo.h>
61 #include <time.h>
62 #include <picldefs.h>
63 #include <picld_pluginutil.h>
64 #include "picllom.h"
65
66 static void picllom_register(void);
67 static void picllom_init(void);
68 static void picllom_fini(void);
69 static node_el_t *create_node_el(picl_nodehdl_t nodeh);
70 static void delete_node_el(node_el_t *pel);
71 static node_list_t *create_node_list();
72 static void delete_node_list_contents(node_list_t *pnl);
73 static void delete_node_list(node_list_t *pnl);
74 static void add_node_to_list(picl_nodehdl_t nodeh,
75 node_list_t *listp);
76 static void get_node_list_by_class(picl_nodehdl_t nodeh,
77 const char *classname, node_list_t *listp);
78 static int get_lom_node(picl_nodehdl_t *lominfh);
79 static int get_lom_device_path(picl_nodehdl_t *lominfh);
80 static int get_node_by_name_and_class(picl_nodehdl_t srchnodeh,
81 const char *nodename, const char *classname, picl_nodehdl_t *chdh);
82 static int add_regular_prop(picl_nodehdl_t nodeh, const char *name,
83 int type, int access, int size, const void *valbuf, picl_prophdl_t *prophp);
84 static int add_volatile_prop(picl_nodehdl_t nodeh, char *name,
85 int type, int access, int size, ptree_vol_rdfunc_t rdfunc,
86 ptree_vol_wrfunc_t wrfunc, picl_prophdl_t *prophp);
87 static int open_lom_rd(int *lom_fd);
88 static int get_lom_temp(int index, tempr_t *temp_p);
89 static int update_voltage_stats();
90 static int get_lom_volts_status(int index, int *voltsStatus_p);
91 static int get_lom_volts_shutdown(int index, int *voltsShutdown_p);
92 static int update_fan_stats();
93 static int get_lom_fan_speed(int index, int *fan_speed);
94 static int read_vol_temp(ptree_rarg_t *parg, void *buf);
95 static int read_vol_volts_status(ptree_rarg_t *parg, void *buf);
96 static int read_vol_volts_shutdown(ptree_rarg_t *parg, void *buf);
97 static int read_fan_speed(ptree_rarg_t *parg, void *buf);
98 static int read_fan_status(ptree_rarg_t *parg, void *buf);
99 static int lookup_led_status(int8_t state, const char **string);
100 static int read_led_status(ptree_rarg_t *parg, void *buf);
101 static void convert_node_name(char *ptr);
102 static int add_temp_sensors(int lom_fd, picl_nodehdl_t lominfh);
103 static int add_voltage_monitors(int lom_fd,
104 picl_nodehdl_t lominfh);
105 static int add_fan_nodes(int lom_fd, picl_nodehdl_t lominfh);
106 static int get_config_file(char *outfilename);
107
108 #pragma init(picllom_register)
109
110 static picld_plugin_reg_t my_reg_info = {
111 PICLD_PLUGIN_VERSION_1,
112 PICLD_PLUGIN_NON_CRITICAL,
113 "SUNW_picllom",
114 picllom_init,
115 picllom_fini
116 };
117
118 static const char str_OK[] = "OK";
119 static const char str_FAIL[] = "FAIL";
120 static const char str_On[] = "on";
121 static const char str_Off[] = "off";
122 static const char str_Enabled[] = "Enabled";
123 static const char str_Disabled[] = "Disabled";
124 static char lom_device_path[PATH_MAX];
125 static tempr_t high_warnings[MAX_TEMPS];
126 static tempr_t high_shutdowns[MAX_TEMPS];
127 static picl_prophdl_t temp_handles[MAX_TEMPS];
128 static lom_fandata_t fandata;
129 static picl_prophdl_t fan_speed_handles[MAX_FANS];
130 static picl_prophdl_t fan_status_handles[MAX_FANS];
131 static lom_volts_t voltsdata;
132 static picl_prophdl_t volts_status_handles[MAX_VOLTS];
133 static picl_prophdl_t volts_shutdown_handles[MAX_VOLTS];
134 static int n_leds = 0;
135 static int max_state_size = 0;
136 static picl_prophdl_t *led_handles = NULL;
137 static char **led_labels = NULL;
138 static lom2_info_t info2data;
139 static struct {
140 int size;
141 char *str_colour;
142 } colour_lkup[1 + LOM_LED_COLOUR_AMBER];
143
144 static struct {
145 int8_t state;
146 char *str_ledstate;
147 } ledstate_lkup[] = {
148 { LOM_LED_OFF },
149 { LOM_LED_ON },
150 { LOM_LED_BLINKING },
151 };
152
153 static node_el_t *
154 create_node_el(picl_nodehdl_t nodeh)
155 {
156 node_el_t *ptr = malloc(sizeof (node_el_t));
157
158 if (ptr != NULL) {
159 ptr->nodeh = nodeh;
160 ptr->next = NULL;
161 }
162
163 return (ptr);
164 }
165
166 static void
167 delete_node_el(node_el_t *pel)
168 {
169 free(pel);
170 }
171
172 static node_list_t *
173 create_node_list()
174 {
175 node_list_t *ptr = malloc(sizeof (node_list_t));
176
177 if (ptr != NULL) {
178 ptr->head = NULL;
179 ptr->tail = NULL;
180 }
181
182 return (ptr);
183 }
184
185 static void
186 delete_node_list_contents(node_list_t *pnl)
187 {
188 node_el_t *pel;
189
190 if (pnl == NULL)
191 return;
192
193 while ((pel = pnl->head) != NULL) {
194 pnl->head = pel->next;
195 delete_node_el(pel);
196 }
197
198 pnl->tail = NULL;
199 }
200
201 static void
202 delete_node_list(node_list_t *pnl)
203 {
204 delete_node_list_contents(pnl);
205 free(pnl);
206 }
207
208 /*
209 * Get a linking element and add handle to end of chain
210 */
211 static void
212 add_node_to_list(picl_nodehdl_t nodeh, node_list_t *listp)
213 {
214 node_el_t *pel = create_node_el(nodeh);
215
216 if (pel != NULL) {
217 if (listp->tail == NULL)
218 listp->head = pel;
219 else
220 listp->tail->next = pel;
221
222 listp->tail = pel;
223 }
224 }
225
226 /*
227 * Get a list of nodes of the specified classname under nodeh.
228 * Once a node of the specified class is found, its children are not
229 * searched.
230 */
231 static void
232 get_node_list_by_class(picl_nodehdl_t nodeh, const char *classname,
233 node_list_t *listp)
234 {
235 int err;
236 char clname[PICL_CLASSNAMELEN_MAX+1];
237 picl_nodehdl_t chdh;
238
239 /*
240 * go through the children
241 */
242 err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
243 sizeof (picl_nodehdl_t));
244
245 while (err == PICL_SUCCESS) {
246 err = ptree_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
247 clname, strlen(classname) + 1);
248
249 if ((err == PICL_SUCCESS) && (strcmp(clname, classname) == 0))
250 add_node_to_list(chdh, listp);
251 else
252 get_node_list_by_class(chdh, classname, listp);
253
254 err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
255 sizeof (picl_nodehdl_t));
256 }
257 }
258
259 static int
260 get_lom_node(picl_nodehdl_t *lominfh)
261 {
262 int err = PICL_SUCCESS;
263 node_list_t *listp;
264
265 listp = create_node_list();
266
267 if ((err = ptree_get_node_by_path(PICL_NODE_ROOT PICL_NODE_PLATFORM,
268 lominfh)) != PICL_SUCCESS) {
269 syslog(LOG_ERR, EM_MISSING_NODE,
270 PICL_NODE_ROOT PICL_NODE_PLATFORM);
271 return (err); /* no /platform ! */
272 }
273
274 get_node_list_by_class(*lominfh, PICL_CLASS_SERVICE_PROCESSOR, listp);
275
276 if (listp->head == NULL) {
277 *lominfh = 0;
278 syslog(LOG_ERR, EM_MISSING_NODE, PICL_CLASS_SERVICE_PROCESSOR);
279 err = PICL_NODENOTFOUND;
280 } else {
281 *lominfh = listp->head->nodeh;
282
283 if (listp->head != listp->tail)
284 syslog(LOG_ERR, EM_LOM_DUPLICATE);
285 }
286
287 delete_node_list(listp);
288 return (err);
289 }
290
291 static int
292 get_lom_device_path(picl_nodehdl_t *lominfh)
293 {
294 int err = PICL_SUCCESS;
295 char devfs_path[PATH_MAX];
296 char devices_path[PATH_MAX];
297
298 err = ptree_get_propval_by_name(*lominfh, PICL_PROP_DEVFS_PATH,
299 devfs_path, sizeof (devfs_path));
300
301 /* Build up the full device path and set the global */
302 strcpy(devices_path, "/devices");
303 strcat(devices_path, devfs_path);
304 strcat(devices_path, LOM_DEV_MINOR_NAME);
305 strcpy(lom_device_path, devices_path);
306
307 return (err);
308
309 }
310
311
312
313
314 /*
315 * Look for a node of specified name and class
316 * Confine search to nodes one level below that of supplied handle
317 */
318 static int
319 get_node_by_name_and_class(picl_nodehdl_t srchnodeh, const char *nodename,
320 const char *classname, picl_nodehdl_t *chdh)
321 {
322 int err;
323 char namebuf[PATH_MAX];
324
325 err = ptree_get_propval_by_name(srchnodeh, PICL_PROP_CHILD, chdh,
326 sizeof (picl_nodehdl_t));
327
328 while (err == PICL_SUCCESS) {
329 err = ptree_get_propval_by_name(*chdh, PICL_PROP_NAME, namebuf,
330 sizeof (namebuf));
331 if (err != PICL_SUCCESS)
332 break;
333 if (strcmp(namebuf, nodename) == 0) {
334 err = ptree_get_propval_by_name(*chdh,
335 PICL_PROP_CLASSNAME, namebuf, sizeof (namebuf));
336 if ((err == PICL_SUCCESS) &&
337 (strcmp(namebuf, classname) == 0))
338 return (PICL_SUCCESS);
339 }
340 err = ptree_get_propval_by_name(*chdh, PICL_PROP_PEER, chdh,
341 sizeof (picl_nodehdl_t));
342 }
343
344 return (err);
345 }
346
347 /*
348 * Create and add the specified regular property
349 */
350
351 static int
352 add_regular_prop(picl_nodehdl_t nodeh, const char *name, int type, int access,
353 int size, const void *valbuf, picl_prophdl_t *prophp)
354 {
355 int err;
356 ptree_propinfo_t propinfo;
357 picl_prophdl_t proph;
358
359 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
360 type, access, size, (char *)name, NULL, NULL);
361 if (err != PICL_SUCCESS)
362 return (err);
363
364 err = ptree_create_and_add_prop(nodeh, &propinfo, (void *)valbuf,
365 &proph);
366 if (err == PICL_SUCCESS && prophp)
367 *prophp = proph;
368 return (err);
369 }
370
371
372 /*
373 * Create and add the specified volatile property
374 */
375 static int
376 add_volatile_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
377 int size, ptree_vol_rdfunc_t rdfunc, ptree_vol_wrfunc_t wrfunc,
378 picl_prophdl_t *prophp)
379 {
380 int err;
381 ptree_propinfo_t propinfo;
382 picl_prophdl_t proph;
383
384 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
385 type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc);
386 if (err != PICL_SUCCESS)
387 return (err);
388
389 err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph);
390 if (err == PICL_SUCCESS && prophp)
391 *prophp = proph;
392 return (err);
393 }
394
395 /*
396 * open LOM device to read
397 */
398 static int
399 open_lom_rd(int *lom_fd)
400 {
401 *lom_fd = open(lom_device_path, O_RDONLY);
402
403 if (*lom_fd < 0)
404 return (PICL_FAILURE);
405
406 return (PICL_SUCCESS);
407 }
408
409 /*
410 * Function to open LOM and read temperature sensor values.
411 * The index to a specific sensor is supplied and that value returned.
412 */
413 static int
414 get_lom_temp(int index, tempr_t *temp_p)
415 {
416 lom_temp_t lom_temp;
417 int lom_fd;
418 int err;
419 int res;
420
421 err = open_lom_rd(&lom_fd);
422
423 if (err == PICL_SUCCESS) {
424 res = ioctl(lom_fd, LOMIOCTEMP, &lom_temp);
425 (void) close(lom_fd);
426
427 if (res == 0) {
428 *temp_p = lom_temp.temp[index];
429 } else {
430 err = PICL_FAILURE;
431 }
432 }
433
434 return (err);
435 }
436
437 /*
438 * Function to open LOM and read voltage monitor values.
439 * Called for each property, so only perform update if time has changed
440 */
441 static int
442 update_voltage_stats()
443 {
444 static time_t then = 0;
445 int lom_fd;
446 int err;
447 int res;
448 time_t now = time(NULL);
449
450 if (now == then)
451 return (PICL_SUCCESS);
452
453 then = now;
454 err = open_lom_rd(&lom_fd);
455
456 if (err == PICL_SUCCESS) {
457 res = ioctl(lom_fd, LOMIOCVOLTS, &voltsdata);
458 (void) close(lom_fd);
459 if (res < 0) {
460 err = PICL_FAILURE;
461 }
462 }
463
464 return (err);
465 }
466
467 /*
468 * Function to open LOM and read voltage monitor values.
469 * The index to a specific voltage status is supplied and that value returned.
470 */
471 static int
472 get_lom_volts_status(int index, int *voltsStatus_p)
473 {
474 int res;
475
476 if ((res = update_voltage_stats()) != PICL_SUCCESS)
477 return (res);
478
479 *voltsStatus_p = voltsdata.status[index];
480 return (PICL_SUCCESS);
481 }
482
483 /*
484 * Function to open LOM and read voltage monitor values.
485 * The index to a specific shutdown flag is supplied and that value returned.
486 */
487 static int
488 get_lom_volts_shutdown(int index, int *voltsShutdown_p)
489 {
490 int res;
491
492 if ((res = update_voltage_stats()) != PICL_SUCCESS)
493 return (res);
494
495 *voltsShutdown_p = voltsdata.shutdown_enabled[index];
496 return (PICL_SUCCESS);
497 }
498
499
500
501 /*
502 * Function to open LOM and read fan values.
503 * Called for each property, so only perform update if time has changed
504 */
505 static int
506 update_fan_stats()
507 {
508 static time_t then = 0;
509 int lom_fd;
510 int err;
511 int res;
512 time_t now = time(NULL);
513
514 if (now == then)
515 return (PICL_SUCCESS);
516
517 then = now;
518 err = open_lom_rd(&lom_fd);
519 if (err == PICL_SUCCESS) {
520 res = ioctl(lom_fd, LOMIOCFANSTATE, &fandata);
521 (void) close(lom_fd);
522 if (res < 0) {
523 err = PICL_FAILURE;
524 }
525 }
526
527 return (err);
528 }
529
530
531
532 /*
533 * The index to a specific fan is supplied and its speed value returned.
534 */
535 static int
536 get_lom_fan_speed(int index, int *fan_speed)
537 {
538 int res;
539
540 if ((res = update_fan_stats()) != PICL_SUCCESS)
541 return (res);
542
543 *fan_speed = fandata.speed[index];
544 return (PICL_SUCCESS);
545 }
546
547
548 /*
549 * Read function for volatile "Temperature" property via LOM
550 */
551 static int
552 read_vol_temp(ptree_rarg_t *parg, void *buf)
553 {
554 tempr_t temp;
555 picl_prophdl_t proph;
556 int index;
557
558 /*
559 * get the sensor index from the displacement of the
560 * property handle and get its temperature.
561 */
562 proph = parg->proph;
563 for (index = 0; index < MAX_TEMPS; index++) {
564 if (temp_handles[index] == proph)
565 break;
566 }
567
568 if (index == MAX_TEMPS) {
569 /*
570 * Handle not found. As this is a plugin, stale handles
571 * cannot occur, so just fail.
572 */
573 return (PICL_FAILURE);
574 }
575
576 if (get_lom_temp(index, &temp) != PICL_SUCCESS)
577 return (PICL_FAILURE);
578 (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
579 return (PICL_SUCCESS);
580 }
581
582 /*
583 * Read function for volatile "VoltageStatus" property via LOM
584 */
585 static int
586 read_vol_volts_status(ptree_rarg_t *parg, void *buf)
587 {
588 int voltsStatus;
589 picl_prophdl_t proph;
590 int index;
591
592 /*
593 * get the voltage monitor index from the displacement of the
594 * status property handle and get its status.
595 */
596 proph = parg->proph;
597
598 for (index = 0; index < MAX_VOLTS; index++) {
599 if (volts_status_handles[index] == proph)
600 break;
601 }
602
603 if (index == MAX_VOLTS)
604 return (PICL_FAILURE);
605
606 if (get_lom_volts_status(index, &voltsStatus) != PICL_SUCCESS)
607 return (PICL_FAILURE);
608
609 (void) strlcpy(buf, (voltsStatus == 0) ? str_OK : str_FAIL,
610 sizeof (str_FAIL));
611 return (PICL_SUCCESS);
612 }
613
614 /*
615 * Read function for volatile "VoltageShutdown" property via LOM
616 */
617 static int
618 read_vol_volts_shutdown(ptree_rarg_t *parg, void *buf)
619 {
620 int voltsShutdown;
621 picl_prophdl_t proph;
622 int index;
623
624 /*
625 * get the voltage monitor index from the displacement of the
626 * shutdown property handle and get its value.
627 */
628 proph = parg->proph;
629
630 for (index = 0; index < MAX_VOLTS; index++) {
631 if (volts_shutdown_handles[index] == proph)
632 break;
633 }
634
635 if (index == MAX_VOLTS)
636 return (PICL_FAILURE);
637
638 if (get_lom_volts_shutdown(index, &voltsShutdown) != PICL_SUCCESS)
639 return (PICL_FAILURE);
640
641 (void) strlcpy(buf, (voltsShutdown == 0) ? str_Disabled : str_Enabled,
642 sizeof (str_Disabled));
643 return (PICL_SUCCESS);
644 }
645
646
647 /*
648 * Read function for volatile fan speed property via LOM
649 */
650 static int
651 read_fan_speed(ptree_rarg_t *parg, void *buf)
652 {
653 int fan_speed;
654 picl_prophdl_t proph;
655 int index;
656
657 /*
658 * get the relevant fan from the displacement of its property handle
659 */
660 proph = parg->proph;
661
662 for (index = 0; index < MAX_FANS; index++) {
663 if (fan_speed_handles[index] == proph)
664 break;
665 }
666
667 if (index == MAX_FANS)
668 return (PICL_FAILURE);
669
670 if (get_lom_fan_speed(index, &fan_speed) != PICL_SUCCESS)
671 return (PICL_FAILURE);
672
673 (void) memcpy(buf, (caddr_t)&fan_speed, sizeof (fan_speed));
674 return (PICL_SUCCESS);
675 }
676
677 /*
678 * look up function to convert led status into string
679 */
680 static int
681 lookup_led_status(int8_t state, const char **string)
682 {
683 int i;
684 int lim = sizeof (ledstate_lkup) / sizeof (ledstate_lkup[0]);
685
686 for (i = 0; i < lim; i++) {
687 if (ledstate_lkup[i].state == state) {
688 *string = ledstate_lkup[i].str_ledstate;
689 return (PICL_SUCCESS);
690 }
691 }
692
693 *string = "";
694 switch (state) {
695 case LOM_LED_ACCESS_ERROR:
696 return (PICL_PROPVALUNAVAILABLE);
697 case LOM_LED_NOT_IMPLEMENTED:
698 /*FALLTHROUGH*/
699 case LOM_LED_OUTOFRANGE:
700 /*FALLTHROUGH*/
701 default:
702 return (PICL_FAILURE);
703 }
704 }
705
706 /*
707 * Read function for volatile led status property.
708 */
709 static int
710 read_led_status(ptree_rarg_t *parg, void *buf)
711 {
712 lom_led_state_t led_data;
713 picl_prophdl_t proph;
714 int index;
715 int lom_fd;
716 int res;
717 const char *string;
718
719 /*
720 * get the relevant led from the displacement of its property handle
721 */
722 proph = parg->proph;
723
724 for (index = 0; index < n_leds; index++) {
725 if (led_handles[index] == proph)
726 break;
727 }
728
729 if (index == n_leds)
730 return (PICL_FAILURE);
731
732 res = open_lom_rd(&lom_fd);
733 if (res != PICL_SUCCESS)
734 return (res);
735 /*
736 * The interface for reading LED status doesn't promise to maintain
737 * a constant mapping between LED index number and LED identity
738 * (as defined by its label). On the other hand, PICL does promise
739 * that whilst a handle remains valid the object it represents will
740 * remain constant. To reconcile these positions, we maintain
741 * tables of labels and handles linked by index value. We search
742 * for the handle with which we are presented and then locate its
743 * label. Then we request LED entries from the LOM and compare their
744 * labels with the one we seek. As an optimisation, we try the original
745 * index value first and then revert to a full search.
746 */
747 (void) memset(&led_data, 0, sizeof (led_data));
748 led_data.index = index;
749 res = ioctl(lom_fd, LOMIOCLEDSTATE, &led_data);
750
751 if (res != 0 || led_data.state == LOM_LED_NOT_IMPLEMENTED ||
752 strcmp(led_data.label, led_labels[index]) != 0) {
753 /*
754 * full scan required (bet it doesn't work!)
755 * first re-establish the range to scan
756 */
757 int i;
758 int n;
759
760 (void) memset(&led_data, 0, sizeof (led_data));
761 led_data.index = -1;
762 res = ioctl(lom_fd, LOMIOCLEDSTATE, &led_data);
763
764 if (res != 0) {
765 (void) close(lom_fd);
766 return (PICL_PROPVALUNAVAILABLE);
767 }
768
769 if (led_data.state == LOM_LED_NOT_IMPLEMENTED ||
770 strcmp(led_data.label, led_labels[index]) != 0) {
771 n = led_data.index;
772 for (i = 0; i < n; i++) {
773 (void) memset(&led_data, 0, sizeof (led_data));
774 led_data.index = i;
775 res = ioctl(lom_fd, LOMIOCLEDSTATE, &led_data);
776
777 if (res == 0 &&
778 led_data.state != LOM_LED_NOT_IMPLEMENTED ||
779 strcmp(led_data.label, led_labels[index]) ==
780 0) {
781 break;
782 }
783 }
784
785 if (i == n) {
786 (void) close(lom_fd);
787 return (PICL_PROPVALUNAVAILABLE);
788 }
789 }
790 }
791
792 /*
793 * if we get here, then we found the right LED.
794 */
795 (void) close(lom_fd);
796 res = lookup_led_status(led_data.state, &string);
797 (void) strlcpy(buf, string, max_state_size);
798 return (res);
799 }
800
801 /*
802 * Read function for volatile fan status property.
803 * This is a synthesized property using speed and min speed properties
804 */
805 static int
806 read_fan_status(ptree_rarg_t *parg, void *buf)
807 {
808 int fan_speed;
809 picl_prophdl_t proph;
810 int index;
811
812 /*
813 * get the relevant fan from the displacement of its property handle
814 */
815 proph = parg->proph;
816
817 for (index = 0; index < MAX_FANS; index++) {
818 if (fan_status_handles[index] == proph)
819 break;
820 }
821
822 if (index == MAX_FANS)
823 return (PICL_FAILURE);
824
825 if (get_lom_fan_speed(index, &fan_speed) != PICL_SUCCESS)
826 return (PICL_FAILURE);
827
828 (void) strlcpy(buf,
829 fan_speed < fandata.minspeed[index] ? str_FAIL : str_OK,
830 sizeof (str_FAIL));
831 return (PICL_SUCCESS);
832 }
833
834
835
836 /*
837 * change to lower case and convert any spaces into hyphens
838 */
839 static void
840 convert_node_name(char *ptr)
841 {
842 char ch;
843
844 for (ch = *ptr; ch != '\0'; ch = *++ptr) {
845 if (isupper(ch)) {
846 *ptr = tolower(ch);
847 } else if (isspace(ch)) {
848 *ptr = '-';
849 }
850 }
851 }
852
853 static int
854 add_temp_sensors(int lom_fd, picl_nodehdl_t lominfh)
855 {
856 lom_temp_t lom_temp;
857 int res;
858 int i;
859 int err = PICL_SUCCESS;
860 const char *cptr;
861
862 res = ioctl(lom_fd, LOMIOCTEMP, &lom_temp);
863
864 if ((res == 0) && (lom_temp.num > 0)) {
865 /*
866 * for each temperature location add a sensor node
867 */
868 for (i = 0; i < lom_temp.num; i++) {
869 picl_nodehdl_t tempsensh;
870 picl_prophdl_t proph;
871
872 high_warnings[i] = lom_temp.warning[i];
873 high_shutdowns[i] = lom_temp.shutdown[i];
874
875 convert_node_name(lom_temp.name[i]);
876
877 err = ptree_create_node(lom_temp.name[i],
878 PICL_CLASS_TEMPERATURE_SENSOR, &tempsensh);
879 if (err != PICL_SUCCESS)
880 break;
881
882 err = add_volatile_prop(tempsensh,
883 PICL_PROP_TEMPERATURE, PICL_PTYPE_INT, PICL_READ,
884 sizeof (tempr_t), read_vol_temp, NULL,
885 &temp_handles[i]);
886 if (err != PICL_SUCCESS)
887 break;
888
889 if (high_warnings[i] != 0) {
890 err = add_regular_prop(
891 tempsensh, PICL_PROP_HIGH_WARNING,
892 PICL_PTYPE_INT, PICL_READ,
893 sizeof (tempr_t), &high_warnings[i],
894 &proph);
895 if (err != PICL_SUCCESS)
896 break;
897 }
898
899 if (high_shutdowns[i] != 0) {
900 err = add_regular_prop(
901 tempsensh, PICL_PROP_HIGH_SHUTDOWN,
902 PICL_PTYPE_INT, PICL_READ,
903 sizeof (tempr_t), &high_shutdowns[i],
904 &proph);
905 if (err != PICL_SUCCESS)
906 break;
907 }
908
909 /*
910 * for the benefit of prtdiag, add a label of
911 * either enclosure or die where appropriate
912 */
913 if ((strcasestr(lom_temp.name[i], CPU_ENCLOSURE) !=
914 NULL) ||
915 (strcasestr(lom_temp.name[i], CPU_AMBIENT) !=
916 NULL)) {
917 cptr = CPU_AMBIENT;
918 } else if ((cptr = strcasestr(lom_temp.name[i],
919 CPU_DIE)) != NULL) {
920 cptr = CPU_DIE;
921 }
922
923 if (cptr != NULL) {
924 err = add_regular_prop(
925 tempsensh, PICL_PROP_LABEL,
926 PICL_PTYPE_CHARSTRING, PICL_READ,
927 strlen(cptr) + 1, cptr, &proph);
928
929 if (err != PICL_SUCCESS) {
930 break;
931 }
932 }
933
934 err = ptree_add_node(lominfh, tempsensh);
935
936 if (err != PICL_SUCCESS)
937 break;
938 }
939
940 if (err != PICL_SUCCESS) {
941 syslog(LOG_ERR, EM_LOMINFO_TREE_FAILED);
942 }
943 }
944
945 return (err);
946 }
947
948 static int
949 add_voltage_monitors(int lom_fd, picl_nodehdl_t lominfh)
950 {
951 int res;
952 int i;
953 int err = PICL_SUCCESS;
954 picl_prophdl_t proph;
955
956 res = ioctl(lom_fd, LOMIOCVOLTS, &voltsdata);
957
958 if ((res == 0) && (voltsdata.num > 0)) {
959 /*
960 * for each voltage monitor add a monitor node
961 */
962 for (i = 0; i < voltsdata.num; i++) {
963 picl_nodehdl_t voltsmonh;
964
965 convert_node_name(voltsdata.name[i]);
966
967 err = ptree_create_node(voltsdata.name[i],
968 PICL_CLASS_VOLTAGE_INDICATOR, &voltsmonh);
969 if (err != PICL_SUCCESS)
970 break;
971
972 err = add_regular_prop(voltsmonh, PICL_PROP_LABEL,
973 PICL_PTYPE_CHARSTRING, PICL_READ,
974 strlen(voltsdata.name[i]) + 1,
975 voltsdata.name[i], &proph);
976 if (err != PICL_SUCCESS)
977 break;
978
979 err = add_volatile_prop(voltsmonh, PICL_VOLTS_SHUTDOWN,
980 PICL_PTYPE_CHARSTRING, PICL_READ,
981 sizeof (str_Disabled), read_vol_volts_shutdown,
982 NULL, &volts_shutdown_handles[i]);
983 if (err != PICL_SUCCESS)
984 break;
985
986 err = add_volatile_prop(voltsmonh, PICL_PROP_CONDITION,
987 PICL_PTYPE_CHARSTRING, PICL_READ,
988 sizeof (str_FAIL), read_vol_volts_status, NULL,
989 &volts_status_handles[i]);
990 if (err != PICL_SUCCESS)
991 break;
992
993 err = ptree_add_node(lominfh, voltsmonh);
994
995 if (err != PICL_SUCCESS)
996 break;
997 }
998
999 if (err != PICL_SUCCESS) {
1000 syslog(LOG_ERR, EM_LOMINFO_TREE_FAILED);
1001 }
1002 }
1003
1004 return (err);
1005 }
1006
1007 static void
1008 add_led(const lom_led_state_t *led_state, picl_nodehdl_t lominfh)
1009 {
1010 int err;
1011 picl_nodehdl_t ledh;
1012 picl_nodehdl_t proph;
1013
1014 if (((unsigned char)led_state->state == LOM_LED_STATE_NOT_PRESENT) ||
1015 (led_state->label[0] == '\0')) {
1016 return;
1017 }
1018
1019 err = ptree_create_node(led_state->label, PICL_CLASS_LED, &ledh);
1020 /*
1021 * the led may exist already, e.g. Fault
1022 */
1023 if (err != PICL_SUCCESS)
1024 return;
1025
1026 /*
1027 * Unlike LEDs derived from other interfaces, these are not
1028 * writable. Establish a read-only volatile property.
1029 */
1030 err = add_volatile_prop(ledh, PICL_PROP_STATE, PICL_PTYPE_CHARSTRING,
1031 PICL_READ, max_state_size, read_led_status, NULL,
1032 &led_handles[led_state->index]);
1033 if (err != PICL_SUCCESS)
1034 return;
1035
1036 /*
1037 * if colour was defined for this LED, add a colour property
1038 */
1039 if ((led_state->colour != LOM_LED_COLOUR_NONE) &&
1040 (led_state->colour != LOM_LED_COLOUR_ANY)) {
1041 err = add_regular_prop(ledh, PICL_PROP_COLOR,
1042 PICL_PTYPE_CHARSTRING, PICL_READ,
1043 colour_lkup[led_state->index].size,
1044 colour_lkup[led_state->index].str_colour, &proph);
1045 }
1046 if (err != PICL_SUCCESS)
1047 return;
1048
1049 err = add_regular_prop(ledh, PICL_PROP_LABEL,
1050 PICL_PTYPE_CHARSTRING, PICL_READ, strlen(led_state->label) + 1,
1051 led_state->label, &proph);
1052 if (err != PICL_SUCCESS)
1053 return;
1054
1055 err = ptree_add_node(lominfh, ledh);
1056
1057 if (err != PICL_SUCCESS) {
1058 syslog(LOG_ERR, EM_LOMINFO_TREE_FAILED);
1059 }
1060 }
1061
1062 static void
1063 fixstate(uint8_t state, const char *string, int *max_len)
1064 {
1065 int i;
1066 int len;
1067
1068 for (i = 0; i < (sizeof (ledstate_lkup) / sizeof (ledstate_lkup[0]));
1069 i++) {
1070 if (ledstate_lkup[i].state == state) {
1071 free(ledstate_lkup[i].str_ledstate);
1072 ledstate_lkup[i].str_ledstate = strdup(string);
1073 len = strlen(string);
1074 if (len >= *max_len)
1075 *max_len = len + 1;
1076 break;
1077 }
1078 }
1079 }
1080
1081 static void
1082 add_led_nodes(int lom_fd, picl_nodehdl_t lominfh)
1083 {
1084 lom_led_state_t led_data;
1085 picl_nodehdl_t ledh;
1086 int res;
1087 int i;
1088
1089 /*
1090 * If the led state enquiry ioctl is supported, an enquiry on
1091 * index -1 will return the state of the highest supported index
1092 * value.
1093 */
1094 (void) memset(&led_data, 0, sizeof (led_data));
1095 led_data.index = -1;
1096 res = ioctl(lom_fd, LOMIOCLEDSTATE, &led_data);
1097
1098 if (res != 0)
1099 return;
1100
1101 if (led_labels != NULL) {
1102 for (i = 0; i < n_leds; i++) {
1103 if (led_labels[i] != NULL) {
1104 free(led_labels[i]);
1105 }
1106 }
1107
1108 free(led_labels);
1109 led_labels = NULL;
1110 }
1111
1112 if (led_handles != NULL) {
1113 free(led_handles);
1114 }
1115
1116 n_leds = 0;
1117 led_handles = calloc(led_data.index + 1, sizeof (picl_nodehdl_t));
1118 led_labels = calloc(led_data.index + 1, sizeof (char *));
1119
1120 if ((led_labels == NULL) || (led_handles == NULL)) {
1121 free(led_labels);
1122 free(led_handles);
1123 led_labels = NULL;
1124 led_handles = NULL;
1125 syslog(LOG_ERR, EM_NO_LED_MEM);
1126 return;
1127 }
1128
1129 n_leds = led_data.index + 1;
1130
1131 /*
1132 * For each LED with a valid state, add a node
1133 * and because of the ludicrous API, stache a copy of its label too
1134 */
1135 for (i = 0; i < n_leds; i++) {
1136 (void) memset(&led_data, 0, sizeof (led_data));
1137 led_data.index = i;
1138 res = ioctl(lom_fd, LOMIOCLEDSTATE, &led_data);
1139
1140 if (res != 0)
1141 continue;
1142
1143 if (led_data.state == LOM_LED_OUTOFRANGE ||
1144 led_data.state == LOM_LED_NOT_IMPLEMENTED)
1145 continue;
1146
1147
1148 led_labels[i] = strdup(led_data.label);
1149 convert_node_name(led_data.label);
1150
1151 if (get_node_by_name_and_class(lominfh, led_data.label,
1152 "led", &ledh) != PICL_SUCCESS) {
1153 /*
1154 * only add a new led node,
1155 * if it's not already in place
1156 */
1157 add_led(&led_data, lominfh);
1158 }
1159 }
1160 }
1161
1162 static int
1163 add_fan_nodes(int lom_fd, picl_nodehdl_t lominfh)
1164 {
1165 int res;
1166 int i;
1167 int err = PICL_SUCCESS;
1168
1169 res = ioctl(lom_fd, LOMIOCFANSTATE, &fandata);
1170
1171 if (res == 0) {
1172 /*
1173 * fan data available through lom, remove any placeholder
1174 * fan-unit nodes, they will be superseded via lom.conf
1175 */
1176 char path[80];
1177 int slot;
1178 picl_nodehdl_t fan_unit_h;
1179
1180 for (slot = 0; slot < MAX_FANS; slot++) {
1181 (void) snprintf(path, sizeof (path),
1182 "/frutree/chassis/fan-slot?Slot=%d/fan-unit", slot);
1183 if (ptree_get_node_by_path(path, &fan_unit_h) !=
1184 PICL_SUCCESS)
1185 continue;
1186 if (ptree_delete_node(fan_unit_h) != PICL_SUCCESS)
1187 continue;
1188 (void) ptree_destroy_node(fan_unit_h);
1189 }
1190 /*
1191 * see if fan names can be obtained
1192 */
1193 (void) memset(&info2data, 0, sizeof (info2data));
1194 /*
1195 * if LOMIOCINFO2 not supported, names area
1196 * will remain empty
1197 */
1198 (void) ioctl(lom_fd, LOMIOCINFO2, &info2data);
1199
1200 /*
1201 * for each fan which is present, add a fan node
1202 */
1203 for (i = 0; i < MAX_FANS; i++) {
1204 char fanname[80];
1205 picl_nodehdl_t fanh;
1206 picl_nodehdl_t proph;
1207
1208 if (fandata.fitted[i] == 0)
1209 continue;
1210
1211 if (info2data.fan_names[i][0] == '\0') {
1212 (void) snprintf(fanname, sizeof (fanname),
1213 "fan%d", i + 1);
1214 } else {
1215 (void) strlcpy(fanname, info2data.fan_names[i],
1216 sizeof (fanname));
1217 }
1218 convert_node_name(fanname);
1219 err = ptree_create_node(fanname, PICL_CLASS_FAN, &fanh);
1220 if (err != PICL_SUCCESS)
1221 break;
1222
1223 err = add_volatile_prop(fanh, PICL_PROP_FAN_SPEED,
1224 PICL_PTYPE_INT, PICL_READ, sizeof (int),
1225 read_fan_speed, NULL, &fan_speed_handles[i]);
1226 if (err != PICL_SUCCESS)
1227 break;
1228
1229 err = add_regular_prop(fanh, PICL_PROP_LOW_WARNING,
1230 PICL_PTYPE_INT, PICL_READ, sizeof (int),
1231 &fandata.minspeed[i], &proph);
1232 if (err != PICL_SUCCESS)
1233 break;
1234
1235 err = add_regular_prop(fanh, PICL_PROP_FAN_SPEED_UNIT,
1236 PICL_PTYPE_CHARSTRING, PICL_READ, sizeof ("%"),
1237 "%", &proph);
1238 if (err != PICL_SUCCESS)
1239 break;
1240
1241 err = add_volatile_prop(fanh, PICL_PROP_CONDITION,
1242 PICL_PTYPE_CHARSTRING, PICL_READ,
1243 sizeof (str_FAIL), read_fan_status, NULL,
1244 &fan_status_handles[i]);
1245 if (err != PICL_SUCCESS)
1246 break;
1247
1248 /*
1249 * add a label for prtdiag
1250 */
1251 err = add_regular_prop(fanh, PICL_PROP_LABEL,
1252 PICL_PTYPE_CHARSTRING, PICL_READ,
1253 strlen(fanname) + 1, fanname, &proph);
1254 if (err != PICL_SUCCESS)
1255 break;
1256
1257 err = ptree_add_node(lominfh, fanh);
1258 if (err != PICL_SUCCESS)
1259 break;
1260 }
1261
1262 if (err != PICL_SUCCESS) {
1263 syslog(LOG_ERR, EM_LOMINFO_TREE_FAILED);
1264 }
1265 }
1266
1267 return (err);
1268 }
1269
1270 static void
1271 setup_strings()
1272 {
1273 /*
1274 * initialise led colours lookup
1275 */
1276 int i;
1277 int lim = sizeof (colour_lkup) / sizeof (colour_lkup[0]);
1278
1279 for (i = 0; i < lim; i++) {
1280 free(colour_lkup[i].str_colour);
1281 }
1282
1283 colour_lkup[LOM_LED_COLOUR_ANY].str_colour = strdup(gettext("any"));
1284 colour_lkup[LOM_LED_COLOUR_WHITE].str_colour = strdup(gettext("white"));
1285 colour_lkup[LOM_LED_COLOUR_BLUE].str_colour = strdup(gettext("blue"));
1286 colour_lkup[LOM_LED_COLOUR_GREEN].str_colour = strdup(gettext("green"));
1287 colour_lkup[LOM_LED_COLOUR_AMBER].str_colour = strdup(gettext("amber"));
1288
1289 for (i = 0; i < lim; i++) {
1290 if (colour_lkup[i].str_colour != NULL)
1291 colour_lkup[i].size =
1292 1 + strlen(colour_lkup[i].str_colour);
1293 }
1294
1295 /*
1296 * initialise led state lookup strings
1297 */
1298 fixstate(LOM_LED_OFF, gettext("off"), &max_state_size);
1299 fixstate(LOM_LED_ON, gettext("on"), &max_state_size);
1300 fixstate(LOM_LED_BLINKING, gettext("blinking"), &max_state_size);
1301 }
1302
1303 /*
1304 * The size of outfilename must be PATH_MAX
1305 */
1306 static int
1307 get_config_file(char *outfilename)
1308 {
1309 char nmbuf[SYS_NMLN];
1310 char pname[PATH_MAX];
1311
1312 if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
1313 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
1314 (void) strlcat(pname, LOM_CONFFILE_NAME, PATH_MAX);
1315 if (access(pname, R_OK) == 0) {
1316 (void) strlcpy(outfilename, pname, PATH_MAX);
1317 return (0);
1318 }
1319 }
1320
1321 if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
1322 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
1323 (void) strlcat(pname, LOM_CONFFILE_NAME, PATH_MAX);
1324 if (access(pname, R_OK) == 0) {
1325 (void) strlcpy(outfilename, pname, PATH_MAX);
1326 return (0);
1327 }
1328 }
1329
1330 (void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
1331 LOM_CONFFILE_NAME);
1332
1333 if (access(pname, R_OK) == 0) {
1334 (void) strlcpy(outfilename, pname, PATH_MAX);
1335 return (0);
1336 }
1337
1338 return (-1);
1339 }
1340
1341
1342
1343 /*
1344 * executed as part of .init when the plugin is dlopen()ed
1345 */
1346 static void
1347 picllom_register(void)
1348 {
1349 (void) picld_plugin_register(&my_reg_info);
1350 }
1351
1352 /*
1353 * Init entry point of the plugin
1354 * Creates the PICL nodes and properties in the physical and logical aspects.
1355 */
1356 static void
1357 picllom_init(void)
1358 {
1359 picl_nodehdl_t rooth;
1360 picl_nodehdl_t plfh;
1361 picl_nodehdl_t lominfh;
1362 int lom_fd;
1363 char fullfilename[PATH_MAX];
1364
1365 /*
1366 * Get platform node
1367 */
1368 if (ptree_get_node_by_path(PICL_NODE_ROOT PICL_NODE_PLATFORM, &plfh)
1369 != PICL_SUCCESS) {
1370 syslog(LOG_ERR, EM_MISSING_NODE, PICL_NODE_PLATFORM);
1371 syslog(LOG_ERR, EM_INIT_FAILED);
1372 return;
1373 }
1374
1375 /*
1376 * Get lom node
1377 */
1378 if (get_lom_node(&lominfh) != PICL_SUCCESS) {
1379 syslog(LOG_ERR, EM_LOM_NODE_MISSING);
1380 syslog(LOG_ERR, EM_INIT_FAILED);
1381 return;
1382 }
1383
1384 /*
1385 * Retrive the device path to open
1386 */
1387 if (get_lom_device_path(&lominfh) < 0) {
1388 syslog(LOG_ERR, EM_INIT_FAILED);
1389 return;
1390 }
1391
1392 /*
1393 * Open LOM device and interrogate for devices it monitors
1394 */
1395 if ((lom_fd = open(lom_device_path, O_RDONLY)) < 0) {
1396 syslog(LOG_ERR, EM_SYS_ERR, lom_device_path, strerror(errno));
1397 return;
1398 }
1399
1400 setup_strings();
1401 (void) add_temp_sensors(lom_fd, lominfh);
1402 (void) add_voltage_monitors(lom_fd, lominfh);
1403 (void) add_fan_nodes(lom_fd, lominfh);
1404 add_led_nodes(lom_fd, lominfh);
1405
1406
1407 if (get_config_file(fullfilename) < 0) {
1408 (void) close(lom_fd);
1409 syslog(LOG_ERR, EM_NO_CONFIG);
1410 return;
1411 }
1412
1413 if (ptree_get_root(&rooth) != PICL_SUCCESS) {
1414 (void) close(lom_fd);
1415 return;
1416 }
1417
1418 if (picld_pluginutil_parse_config_file(rooth, fullfilename) !=
1419 PICL_SUCCESS)
1420 syslog(LOG_ERR, EM_INIT_FAILED);
1421
1422 (void) close(lom_fd);
1423 }
1424
1425 /*
1426 * fini entry point of the plugin
1427 */
1428 static void
1429 picllom_fini(void)
1430 {
1431 }
unleashed repo fork