?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cmd: remove sparc-only virtinfo
[unleashed.git] / usr / src / cmd / picl / plugins / sun4u / chicago / envd / piclenvsetup.c
blob0d4578e9eb51998e9ad80b97e78ba3d2495e6960
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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
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 file contains code for setting up environmental related nodes
31 * and properties in the PICL tree.
32 *
33 */
34
35 #include <stdio.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 #include <syslog.h>
39 #include <stdlib.h>
40 #include <limits.h>
41 #include <errno.h>
42 #include <sys/open.h>
43 #include <ctype.h>
44 #include <string.h>
45 #include <alloca.h>
46 #include <libintl.h>
47 #include <sys/systeminfo.h>
48 #include <picl.h>
49 #include <picltree.h>
50 #include <picld_pluginutil.h>
51 #include <pthread.h>
52 #include <sys/utsname.h>
53 #include <sys/systeminfo.h>
54 #include "picldefs.h"
55 #include "envd.h"
56
57 /*
58 * Volatile property read/write function typedef
59 */
60 typedef int ptree_vol_rdfunc_t(ptree_rarg_t *parg, void *buf);
61 typedef int ptree_vol_wrfunc_t(ptree_warg_t *parg, const void *buf);
62
63 extern int disk_temp_monitor;
64 extern env_tuneable_t tuneables[];
65 extern int errno;
66 extern int ntuneables;
67 #define PROP_FAN_SPEED_UNIT_VALUE "rpm"
68
69 /*
70 * Sensor node data structure
71 */
72 typedef struct {
73 char *parent_path; /* parent path */
74 char *sensor_name; /* sensor name */
75 env_sensor_t *sensorp; /* sensor info */
76 picl_nodehdl_t nodeh; /* sensor node handle */
77 picl_prophdl_t proph; /* "Temperature" property handle */
78 picl_prophdl_t target_proph; /* "TargetTemp" property handle */
79 } sensor_node_t;
80
81 /*
82 * Sensor nodes array
83 */
84 static sensor_node_t sensor_nodes[] = {
85 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_CPU0,
86 NULL, NULL, NULL, NULL},
87 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_CPU1,
88 NULL, NULL, NULL, NULL},
89 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_MB,
90 NULL, NULL, NULL, NULL},
91 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_ADT7462,
92 NULL, NULL, NULL, NULL},
93 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_LM95221,
94 NULL, NULL, NULL, NULL},
95 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_FIRE,
96 NULL, NULL, NULL, NULL},
97 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_LSI1064,
98 NULL, NULL, NULL, NULL},
99 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_FRONT_PANEL,
100 NULL, NULL, NULL, NULL},
101 {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_PSU,
102 NULL, NULL, NULL, NULL}
103 };
104 #define N_SENSOR_NODES (sizeof (sensor_nodes)/sizeof (sensor_nodes[0]))
105
106 /*
107 * Fan node data structure
108 */
109 typedef struct {
110 char *parent_path; /* parent node path */
111 char *fan_name; /* fan name */
112 env_fan_t *fanp; /* fan information */
113 char *speed_unit; /* speed unit string */
114 picl_nodehdl_t nodeh; /* "fan" node handle */
115 picl_prophdl_t proph; /* "Speed" property handle */
116 } fan_node_t;
117
118 /*
119 * Fan node array
120 */
121 static fan_node_t fan_nodes[] = {
122 {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN0,
123 NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
124 {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN1,
125 NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
126 {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN2,
127 NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
128 {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN3,
129 NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
130 {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN4,
131 NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL}
132 };
133 #define N_FAN_NODES (sizeof (fan_nodes)/sizeof (fan_nodes[0]))
134
135 /*
136 * Disk node data structure
137 */
138 typedef struct {
139 char *parent_path; /* parent node path */
140 char *disk_name; /* disk name */
141 env_disk_t *diskp; /* disk information */
142 picl_nodehdl_t nodeh; /* "disk" node handle */
143 picl_prophdl_t proph; /* "Temperature" property handle */
144 } disk_node_t;
145
146 /*
147 * Disk node array
148 */
149 static disk_node_t disk_nodes[] = {
150 {DISK0_NODE_PATH, ENV_DISK0, NULL, NULL, NULL},
151 {DISK1_NODE_PATH, ENV_DISK1, NULL, NULL, NULL},
152 {DISK2_NODE_PATH, ENV_DISK2, NULL, NULL, NULL},
153 {DISK3_NODE_PATH, ENV_DISK3, NULL, NULL, NULL}
154 };
155 #define N_DISK_NODES (sizeof (disk_nodes)/sizeof (disk_nodes[0]))
156
157 /*
158 * Miscellaneous declarations
159 */
160 static void delete_sensor_nodes_and_props(void);
161 static void delete_disk_nodes_and_props(void);
162 static void delete_fan_nodes_and_props(void);
163
164
165 /*
166 * Read function for volatile "Temperature" property
167 */
168 static int
169 get_current_temp(ptree_rarg_t *parg, void *buf)
170 {
171 tempr_t temp;
172 picl_prophdl_t proph;
173 sensor_node_t *snodep;
174 int i;
175
176 /*
177 * Locate the sensor in our sensor_nodes table by matching the
178 * property handle and get its temperature.
179 */
180 proph = parg->proph;
181 for (i = 0; i < N_SENSOR_NODES; i++) {
182 snodep = &sensor_nodes[i];
183 if (snodep->proph != proph)
184 continue;
185
186 if (get_temperature(snodep->sensorp, &temp) < 0)
187 break;
188 (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
189 return (PICL_SUCCESS);
190 }
191 return (PICL_FAILURE);
192 }
193
194 /*
195 * Read function for volatile "Temperature" property
196 */
197 static int
198 get_disk_temp(ptree_rarg_t *parg, void *buf)
199 {
200 tempr_t temp;
201 picl_prophdl_t proph;
202 disk_node_t *dnodep;
203 int i;
204
205 /*
206 * Locate the sensor in our sensor_nodes table by matching the
207 * property handle and get its temperature.
208 */
209 proph = parg->proph;
210 for (i = 0; i < N_DISK_NODES; i++) {
211 dnodep = &disk_nodes[i];
212 if (dnodep->proph != proph)
213 continue;
214
215 if (disk_temperature(dnodep->diskp, &temp) < 0)
216 break;
217 (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
218 return (PICL_SUCCESS);
219 }
220 return (PICL_FAILURE);
221 }
222
223 /*
224 * Read function for volatile "Speed" property on "fan" class node
225 */
226 static int
227 set_current_speed(ptree_warg_t *parg, const void *buf)
228 {
229 fanspeed_t speed;
230 picl_prophdl_t proph;
231 fan_node_t *fnodep;
232 int i, ret;
233
234 /*
235 * Locate the fan in our fan_nodes table by matching the
236 * property handle and get fan speed.
237 */
238 proph = parg->proph;
239 for (i = 0; i < N_FAN_NODES; i++) {
240 fnodep = &fan_nodes[i];
241 if (fnodep->proph != proph)
242 continue;
243 if (fnodep->fanp->fd == -1)
244 continue;
245
246 (void) memcpy((caddr_t)&speed, buf, sizeof (speed));
247
248 ret = set_fan_speed(fnodep->fanp, speed);
249
250 if (ret < 0) {
251 if (ret == -1 && errno == EBUSY)
252 return (PICL_NOTWRITABLE);
253 if (ret == -2)
254 return (PICL_INVALIDARG);
255 break;
256 }
257
258
259 return (PICL_SUCCESS);
260 }
261 return (PICL_FAILURE);
262 }
263
264
265 /*
266 * Read function for volatile "Speed" property on "fan" class node
267 */
268 static int
269 get_current_speed(ptree_rarg_t *parg, void *buf)
270 {
271 fanspeed_t speed;
272 picl_prophdl_t proph;
273 fan_node_t *fnodep;
274 int i;
275
276 /*
277 * Locate the fan in our fan_nodes table by matching the
278 * property handle and get fan speed.
279 */
280 proph = parg->proph;
281 for (i = 0; i < N_FAN_NODES; i++) {
282 fnodep = &fan_nodes[i];
283 if (fnodep->proph != proph)
284 continue;
285 if (fnodep->fanp->fd == -1)
286 continue;
287 if (get_fan_speed(fnodep->fanp, &speed) < 0)
288 break;
289
290 (void) memcpy(buf, (caddr_t)&speed, sizeof (speed));
291 return (PICL_SUCCESS);
292 }
293 return (PICL_FAILURE);
294 }
295
296 /*
297 * Create and add the specified regular property
298 */
299
300 static int
301 add_regular_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
302 int size, void *valbuf, picl_prophdl_t *prophp)
303 {
304 int err;
305 ptree_propinfo_t propinfo;
306 picl_prophdl_t proph;
307
308 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
309 type, access, size, name, NULL, NULL);
310 if (err != PICL_SUCCESS)
311 return (err);
312
313 err = ptree_create_and_add_prop(nodeh, &propinfo, valbuf, &proph);
314 if (err == PICL_SUCCESS && prophp)
315 *prophp = proph;
316 return (err);
317 }
318
319
320 /*
321 * Create and add the specified volatile property
322 */
323 static int
324 add_volatile_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
325 int size, ptree_vol_rdfunc_t *rdfunc, ptree_vol_wrfunc_t *wrfunc,
326 picl_prophdl_t *prophp)
327 {
328 int err;
329 ptree_propinfo_t propinfo;
330 picl_prophdl_t proph;
331
332 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
333 type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc);
334 if (err != PICL_SUCCESS)
335 return (err);
336
337 err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph);
338 if (err == PICL_SUCCESS && prophp)
339 *prophp = proph;
340 return (err);
341 }
342
343 /*
344 * Add temperature threshold properties
345 */
346 static void
347 add_sensor_thresh_props(picl_nodehdl_t nodeh, es_sensor_blk_t *sensor_blkp)
348 {
349 picl_prophdl_t proph;
350
351 (void) add_regular_prop(nodeh, PICL_PROP_LOW_POWER_OFF,
352 PICL_PTYPE_INT, PICL_READ,
353 sizeof (sensor_blkp->esb_low_power_off),
354 &sensor_blkp->esb_low_power_off, &proph);
355
356 (void) add_regular_prop(nodeh, PICL_PROP_LOW_SHUTDOWN,
357 PICL_PTYPE_INT, PICL_READ,
358 sizeof (sensor_blkp->esb_low_shutdown),
359 &sensor_blkp->esb_low_shutdown, &proph);
360
361 (void) add_regular_prop(nodeh, PICL_PROP_LOW_WARNING,
362 PICL_PTYPE_INT, PICL_READ,
363 sizeof (sensor_blkp->esb_low_warning),
364 &sensor_blkp->esb_low_warning, &proph);
365
366 (void) add_regular_prop(nodeh, PICL_PROP_HIGH_WARNING,
367 PICL_PTYPE_INT, PICL_READ,
368 sizeof (sensor_blkp->esb_high_warning),
369 &sensor_blkp->esb_high_warning, &proph);
370
371 (void) add_regular_prop(nodeh, PICL_PROP_HIGH_SHUTDOWN,
372 PICL_PTYPE_INT, PICL_READ,
373 sizeof (sensor_blkp->esb_high_shutdown),
374 &sensor_blkp->esb_high_shutdown, &proph);
375
376 (void) add_regular_prop(nodeh, PICL_PROP_HIGH_POWER_OFF,
377 PICL_PTYPE_INT, PICL_READ,
378 sizeof (sensor_blkp->esb_high_power_off),
379 &sensor_blkp->esb_high_power_off, &proph);
380 }
381
382
383 /*
384 * Go through the sensor_nodes array and create those nodes
385 * and the Temperature property to report the temperature.
386 */
387 static int
388 add_sensor_nodes_and_props()
389 {
390 int err;
391 char *pname, *nodename, *devfs_path;
392 sensor_node_t *snodep;
393 picl_nodehdl_t nodeh, cnodeh;
394 picl_prophdl_t proph;
395 env_sensor_t *sensorp;
396 es_sensor_blk_t *sensor_blkp;
397 int i;
398
399 for (i = 0; i < N_SENSOR_NODES; i++) {
400 snodep = &sensor_nodes[i];
401 /*
402 * Get the parent nodeh
403 */
404 err = ptree_get_node_by_path(snodep->parent_path, &nodeh);
405 if (err != PICL_SUCCESS) {
406 if (env_debug)
407 envd_log(LOG_ERR, "failed to get_node_by_path %s\n",
408 snodep->parent_path);
409 continue;
410 }
411 sensorp = snodep->sensorp;
412 if (sensorp == NULL)
413 continue;
414 if (sensorp->present == B_FALSE)
415 continue;
416 /*
417 * Create temperature-sensor node
418 */
419 nodename = snodep->sensor_name;
420 err = ptree_create_and_add_node(nodeh, nodename,
421 PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh);
422 if (env_debug)
423 envd_log(LOG_ERR,
424 "Creating PICL sensor node '%s' err:%d\n",
425 nodename, err);
426 if (err != PICL_SUCCESS)
427 break;
428
429 /* save node handle */
430 snodep->nodeh = cnodeh;
431
432 /*
433 * Add "devfs_path" property in child node
434 */
435 devfs_path = sensorp->devfs_path;
436 pname = PICL_PROP_DEVFS_PATH;
437 err = add_regular_prop(cnodeh, pname,
438 PICL_PTYPE_CHARSTRING, PICL_READ,
439 strlen(devfs_path)+1, (void *)devfs_path, &proph);
440 if (err != PICL_SUCCESS)
441 break;
442
443 /*
444 * Now add volatile "temperature" volatile property
445 * in this "temperature-sensor" class node.
446 */
447 pname = PICL_PROP_TEMPERATURE;
448 err = add_volatile_prop(cnodeh, pname,
449 PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t),
450 get_current_temp, NULL, &proph);
451 if (err != PICL_SUCCESS)
452 break;
453
454 /* Save prop handle */
455 snodep->proph = proph;
456
457 /*
458 * Add threshold related properties
459 */
460 sensor_blkp = sensorp->es;
461 if (sensor_blkp != NULL)
462 add_sensor_thresh_props(cnodeh, sensor_blkp);
463 }
464
465 if (err != PICL_SUCCESS) {
466 delete_sensor_nodes_and_props();
467 if (env_debug)
468 envd_log(LOG_INFO,
469 "Can't create prop/node for sensor '%s'\n",
470 nodename);
471 return (err);
472 }
473 return (PICL_SUCCESS);
474 }
475
476 /*
477 * Delete all sensor nodes and related properties created by the
478 * add_sensor_prop() for each sensor node in the PICL tree.
479 */
480 static void
481 delete_sensor_nodes_and_props(void)
482 {
483 sensor_node_t *snodep;
484 int i;
485
486 /*
487 * Delete/destroy any property created in the sensed device
488 * as well as the sensor node and all properties under it.
489 * Note that deleiing/destroying a node deletes/destroys
490 * all properties within that node.
491 */
492
493 for (i = 0; i < N_SENSOR_NODES; i++) {
494 snodep = &sensor_nodes[i];
495 if (snodep->nodeh != NULL) {
496 /* delete node and all properties under it */
497 (void) ptree_delete_node(snodep->nodeh);
498 (void) ptree_destroy_node(snodep->nodeh);
499 snodep->nodeh = NULL;
500 snodep->proph = NULL;
501 }
502 }
503 }
504
505 /*
506 * Go through the disk_nodes array and create those nodes
507 * and the Temperature property to report the temperature.
508 */
509 static int
510 add_disk_nodes_and_props()
511 {
512 int err;
513 char *pname, *nodename, *devfs_path;
514 disk_node_t *dnodep;
515 picl_nodehdl_t nodeh, cnodeh;
516 picl_prophdl_t proph;
517 env_disk_t *diskp;
518 int i;
519
520 for (i = 0; i < N_DISK_NODES; i++) {
521 if (env_debug)
522 envd_log(LOG_ERR, "adding disk nodes...\n");
523 dnodep = &disk_nodes[i];
524 /*
525 * Get the parent nodeh
526 */
527 err = ptree_get_node_by_path(dnodep->parent_path, &nodeh);
528 if (err != PICL_SUCCESS) {
529 if (env_debug)
530 envd_log(LOG_ERR,
531 "failed to get node for path %s\n",
532 dnodep->parent_path);
533
534 err = PICL_SUCCESS;
535 continue;
536 }
537 diskp = dnodep->diskp;
538 if (diskp == NULL)
539 continue;
540 if (diskp->present == B_FALSE)
541 continue;
542 /*
543 * Create temperature-sensor node
544 */
545 nodename = dnodep->disk_name;
546 err = ptree_create_and_add_node(nodeh, nodename,
547 PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh);
548 if (env_debug)
549 envd_log(LOG_ERR,
550 "Creating PICL disk node '%s' err:%d\n",
551 nodename, err);
552 if (err != PICL_SUCCESS)
553 break;
554
555 /* save node handle */
556 dnodep->nodeh = cnodeh;
557
558 /*
559 * Add "devfs_path" property in child node
560 */
561 devfs_path = diskp->devfs_path;
562 pname = PICL_PROP_DEVFS_PATH;
563 err = add_regular_prop(cnodeh, pname,
564 PICL_PTYPE_CHARSTRING, PICL_READ,
565 strlen(devfs_path)+1, (void *)devfs_path, &proph);
566 if (err != PICL_SUCCESS)
567 break;
568
569 /*
570 * Now add volatile "temperature" volatile property
571 * in this "temperature-sensor" class node.
572 */
573 pname = PICL_PROP_TEMPERATURE;
574 err = add_volatile_prop(cnodeh, pname,
575 PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t),
576 get_disk_temp, NULL, &proph);
577 if (err != PICL_SUCCESS)
578 break;
579
580 /* Save prop handle */
581 dnodep->proph = proph;
582
583 /*
584 * Add threshold related properties
585 */
586
587 (void) add_regular_prop(cnodeh, PICL_PROP_LOW_SHUTDOWN,
588 PICL_PTYPE_INT, PICL_READ,
589 sizeof (diskp->low_shutdown),
590 (void *)&(diskp->low_shutdown), &proph);
591
592 (void) add_regular_prop(cnodeh, PICL_PROP_LOW_WARNING,
593 PICL_PTYPE_INT, PICL_READ,
594 sizeof (diskp->low_warning),
595 (void *)&(diskp->low_warning), &proph);
596
597 (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_WARNING,
598 PICL_PTYPE_INT, PICL_READ,
599 sizeof (diskp->high_warning),
600 (void *)&(diskp->high_warning), &proph);
601
602 (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_SHUTDOWN,
603 PICL_PTYPE_INT, PICL_READ,
604 sizeof (diskp->high_shutdown),
605 (void *)&(diskp->high_shutdown), &proph);
606
607 }
608 if (err != PICL_SUCCESS) {
609 delete_disk_nodes_and_props();
610 if (env_debug)
611 envd_log(LOG_INFO,
612 "Can't create prop/node for disk '%s'\n",
613 nodename);
614 return (err);
615 }
616 return (PICL_SUCCESS);
617 }
618
619 /*
620 * Delete all disk nodes and related properties created by the
621 * add_disk_props() for each disk node in the PICL tree.
622 */
623 static void
624 delete_disk_nodes_and_props(void)
625 {
626 disk_node_t *dnodep;
627 int i;
628
629 /*
630 * Delete/destroy disk node and all properties under it.
631 * Note that deleting/destroying a node deletes/destroys
632 * all properties within that node.
633 */
634
635 for (i = 0; i < N_DISK_NODES; i++) {
636 dnodep = &disk_nodes[i];
637 if (dnodep->nodeh != NULL) {
638 (void) ptree_delete_node(dnodep->nodeh);
639 (void) ptree_destroy_node(dnodep->nodeh);
640 dnodep->nodeh = NULL;
641 dnodep->proph = NULL;
642 }
643 }
644 }
645
646 /*
647 * For each entry in fan_nodes[] array, do the following:
648 * - Create specified "fan" class node.
649 * - Create "Speed" volatile propery under "fan" class node.
650 * - Create "SpeedUnit" property under "fan" class node.
651 */
652 static int
653 add_fan_nodes_and_props()
654 {
655 int err = PICL_FAILURE;
656 char *pname, *nodename, *devfs_path;
657 env_fan_t *fanp;
658 fan_node_t *fnodep;
659 picl_nodehdl_t nodeh, cnodeh;
660 picl_prophdl_t proph;
661 int i;
662
663 for (i = 0; i < N_FAN_NODES; i++) {
664 /*
665 * Add various fan nodes and properties
666 */
667 fnodep = &fan_nodes[i];
668 if (fnodep == NULL)
669 continue;
670 if (fnodep->fanp == NULL)
671 continue;
672 if (fnodep->fanp->present == B_FALSE)
673 continue;
674 /*
675 * get parent nodeh
676 */
677 err = ptree_get_node_by_path(fnodep->parent_path, &nodeh);
678 if (err != PICL_SUCCESS) {
679 if (env_debug)
680 envd_log(LOG_ERR,
681 "node for %s NOT FOUND.\n", fnodep->parent_path);
682 err = PICL_SUCCESS;
683 continue;
684 }
685 /*
686 * Create "fan" class node and save node handle
687 */
688 nodename = fnodep->fan_name;
689 err = ptree_create_and_add_node(nodeh, nodename,
690 PICL_CLASS_FAN, &cnodeh);
691 if (env_debug)
692 envd_log(LOG_ERR,
693 "Creating PICL fan node '%s' err:%d\n",
694 nodename, err);
695
696 if (err != PICL_SUCCESS)
697 break;
698 fnodep->nodeh = cnodeh;
699
700 /*
701 * Add "devfs_path" property in child node
702 */
703 fanp = fnodep->fanp;
704 devfs_path = fanp->devfs_path;
705 pname = PICL_PROP_DEVFS_PATH;
706 err = add_regular_prop(cnodeh, pname,
707 PICL_PTYPE_CHARSTRING, PICL_READ,
708 strlen(devfs_path)+1, (void *)devfs_path, &proph);
709
710 if (err != PICL_SUCCESS)
711
712 break;
713
714 /*
715 * Add "Speed" volatile property in this "fan"
716 * class node and save prop handle.
717 */
718 pname = PICL_PROP_FAN_SPEED;
719
720 err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT,
721 PICL_READ|PICL_WRITE, sizeof (fanspeed_t),
722 get_current_speed, set_current_speed, &proph);
723
724 if (err != PICL_SUCCESS)
725 break;
726 fnodep->proph = proph;
727
728 /*
729 * Add other "fan" class properties
730 */
731 pname = PICL_PROP_FAN_SPEED_UNIT;
732 err = add_regular_prop(cnodeh, pname,
733 PICL_PTYPE_CHARSTRING, PICL_READ,
734 strlen(fnodep->speed_unit)+1,
735 (void *)fnodep->speed_unit, &proph);
736
737 if (err != PICL_SUCCESS)
738 break;
739
740 pname = PICL_PROP_LOW_WARNING;
741 err = add_regular_prop(cnodeh, pname,
742 PICL_PTYPE_INT, PICL_READ,
743 sizeof (fanspeed_t),
744 &(fnodep->fanp->speed_min), &proph);
745
746 if (err != PICL_SUCCESS)
747 break;
748 }
749 if (err != PICL_SUCCESS) {
750 delete_fan_nodes_and_props();
751 return (err);
752 }
753 return (PICL_SUCCESS);
754 }
755
756
757 /*
758 * Delete all fan nodes and related properties created by the
759 * add_fan_props() for each fan node in the PICL tree.
760 */
761 static void
762 delete_fan_nodes_and_props(void)
763 {
764 fan_node_t *fnodep;
765 int i;
766
767 /*
768 * Delete/destroy fan node and all properties under it.
769 * Note that deleting/destroying a node deletes/destroys
770 * all properties within that node.
771 */
772
773 for (i = 0; i < N_FAN_NODES; i++) {
774 fnodep = &fan_nodes[i];
775 if (fnodep->nodeh != NULL) {
776 (void) ptree_delete_node(fnodep->nodeh);
777 (void) ptree_destroy_node(fnodep->nodeh);
778 fnodep->nodeh = NULL;
779 }
780 }
781 }
782 /*
783 * Tuneables publishing functions
784 */
785 static int
786 copy_persistent_tuneable(env_tuneable_t *tune, char *buf)
787 {
788
789 switch (tune->type) {
790 case PICL_PTYPE_INT : {
791 (void) memcpy((int *)tune->value,
792 buf, tune->nbytes);
793 break;
794 }
795 case PICL_PTYPE_CHARSTRING : {
796 (void) memcpy((caddr_t)tune->value,
797 buf, tune->nbytes);
798 break;
799 }
800 default : {
801 return (PICL_FAILURE);
802 }
803 }
804 return (PICL_SUCCESS);
805 }
806
807 static void
808 env_parse_tunables(picl_nodehdl_t rooth)
809 {
810 char nmbuf[SYS_NMLN];
811 char pname[PATH_MAX];
812
813 if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
814 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
815 (void) strlcat(pname, TUNABLE_CONF_FILE, PATH_MAX);
816 if (access(pname, R_OK) == 0) {
817 (void) picld_pluginutil_parse_config_file(rooth, pname);
818 return;
819 }
820 }
821 }
822
823 int
824 env_picl_setup_tuneables(void)
825 {
826 int err;
827 int i;
828 picl_nodehdl_t nodeh;
829 picl_nodehdl_t rooth;
830 picl_prophdl_t proph;
831 env_tuneable_t *tuneablep;
832 char read_buf[BUFSIZ];
833
834 if (ptree_get_root(&rooth) != PICL_SUCCESS) {
835 return (PICL_FAILURE);
836 }
837 err = ptree_create_and_add_node(rooth, PICL_PLUGINS_NODE,
838 PICL_CLASS_PICL, &nodeh);
839 if (err != PICL_SUCCESS)
840 return (PICL_FAILURE);
841 err = ptree_create_and_add_node(nodeh, PICL_ENVIRONMENTAL_NODE,
842 PICL_CLASS_PICL, &nodeh);
843 if (err != PICL_SUCCESS) {
844 return (PICL_FAILURE);
845 }
846
847 /*
848 * Parse the conf file
849 */
850 if (env_debug)
851 envd_log(LOG_ERR, "parsing tuneables...\n");
852 env_parse_tunables(rooth);
853 for (i = 0; i < ntuneables; i++) {
854 if (env_debug)
855 envd_log(LOG_ERR, "tuneable %d being added\n", i);
856 tuneablep = &tuneables[i];
857 err = ptree_get_propval_by_name(nodeh, tuneablep->name,
858 read_buf, tuneablep->nbytes);
859
860 if (err != PICL_SUCCESS) {
861 /*
862 * Add volitle functions to environmental node
863 */
864 err = add_volatile_prop(nodeh, tuneablep->name,
865 tuneablep->type,
866 PICL_READ|PICL_WRITE, tuneablep->nbytes,
867 tuneablep->rfunc,
868 tuneablep->wfunc, &proph);
869
870 tuneablep->proph = proph;
871 } else {
872 /*
873 * property is persistent
874 */
875 (void) copy_persistent_tuneable(tuneablep,
876 read_buf);
877 }
878 }
879
880 return (PICL_SUCCESS);
881 }
882
883 /*
884 * Find the ENVMODEL_CONF_FILE file.
885 */
886 static int
887 get_envmodel_conf_file(char *outfilename)
888 {
889 char nmbuf[SYS_NMLN];
890 char pname[PATH_MAX];
891
892 if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
893 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
894 (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX);
895 if (access(pname, R_OK) == 0) {
896 (void) strlcpy(outfilename, pname, PATH_MAX);
897 return (0);
898 }
899 }
900
901 if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
902 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
903 (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX);
904 if (access(pname, R_OK) == 0) {
905 (void) strlcpy(outfilename, pname, PATH_MAX);
906 return (0);
907 }
908 }
909
910 (void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
911 ENV_CONF_FILE);
912
913 if (access(pname, R_OK) == 0) {
914 (void) strlcpy(outfilename, pname, PATH_MAX);
915 return (0);
916 }
917
918 return (-1);
919 }
920
921 /* Delete all sensor/fan nodes and any properties created by this plugin */
922 void
923 env_picl_destroy(void)
924 {
925 delete_fan_nodes_and_props();
926 delete_sensor_nodes_and_props();
927 delete_disk_nodes_and_props();
928 }
929
930 void
931 env_picl_setup(void)
932 {
933 int err, sensor_err, fan_err, disk_err;
934 sensor_node_t *snodep;
935 fan_node_t *fnodep;
936 disk_node_t *dnodep;
937 picl_nodehdl_t plath;
938 char fullfilename[PATH_MAX];
939 picl_nodehdl_t rooth;
940 int i;
941
942
943 /*
944 * Initialize sensorp and other fields in the sensor_nodes[] array
945 */
946
947 for (i = 0; i < N_SENSOR_NODES; i++) {
948 snodep = &sensor_nodes[i];
949 snodep->sensorp = sensor_lookup(snodep->sensor_name);
950 snodep->nodeh = NULL;
951 snodep->proph = NULL;
952 snodep->target_proph = NULL;
953 }
954
955 /*
956 * Initialize fanp and other fields in the fan_nodes[] array
957 */
958 for (i = 0; i < N_FAN_NODES; i++) {
959 fnodep = &fan_nodes[i];
960 fnodep->fanp = fan_lookup(fnodep->fan_name);
961 fnodep->nodeh = NULL;
962 fnodep->proph = NULL;
963 }
964
965 /*
966 * Initialize diskp and other fields in the disk_nodes[] array
967 */
968 for (i = 0; i < N_DISK_NODES; i++) {
969 dnodep = &disk_nodes[i];
970 dnodep->diskp = disk_lookup(dnodep->disk_name);
971 dnodep->nodeh = NULL;
972 dnodep->proph = NULL;
973 }
974
975 /*
976 * Get platform handle and populate PICL tree with environmental
977 * nodes and properties
978 */
979 err = ptree_get_node_by_path("/platform", &plath);
980
981 if (err == PICL_SUCCESS) {
982 sensor_err = add_sensor_nodes_and_props();
983 fan_err = add_fan_nodes_and_props();
984 if (disk_temp_monitor)
985 disk_err = add_disk_nodes_and_props();
986 }
987
988 /*
989 * We can safely call delete_xxx_nodes_and_props even
990 * if nodes were not added.
991 */
992
993 if (err != PICL_SUCCESS) {
994 if (fan_err != PICL_SUCCESS)
995 delete_fan_nodes_and_props();
996 if (disk_err != PICL_SUCCESS)
997 delete_disk_nodes_and_props();
998 if (sensor_err != PICL_SUCCESS)
999 delete_sensor_nodes_and_props();
1000
1001 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1002 return;
1003 }
1004 if (env_debug)
1005 envd_log(LOG_ERR, "parsing the envmodel.conf file...\n");
1006
1007 /*
1008 * Parse the envmodel.conf file and populate the PICL tree
1009 */
1010 if (get_envmodel_conf_file(fullfilename) < 0)
1011 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1012 if (ptree_get_root(&rooth) != PICL_SUCCESS)
1013 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1014 err = picld_pluginutil_parse_config_file(rooth, fullfilename);
1015
1016 if (err != PICL_SUCCESS)
1017 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1018 }
Unleashed OS