/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * This file contains code for setting up environmental related nodes * and properties in the PICL tree. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "picldefs.h" #include "envd.h" /* * Volatile property read/write function typedef */ typedef int ptree_vol_rdfunc_t(ptree_rarg_t *parg, void *buf); typedef int ptree_vol_wrfunc_t(ptree_warg_t *parg, const void *buf); extern int monitor_disk_temp; extern sensor_ctrl_blk_t sensor_ctrl[]; extern fan_ctrl_blk_t fan_ctrl[]; extern env_tuneable_t tuneables[]; extern int errno; extern int ntuneables; #define PROP_FAN_SPEED_UNIT_VALUE "rpm" /* * Sensor node data structure */ typedef struct { char *parent_path; /* parent path */ char *sensor_name; /* sensor name */ env_sensor_t *sensorp; /* sensor info */ picl_nodehdl_t nodeh; /* sensor node handle */ picl_prophdl_t proph; /* "Temperature" property handle */ picl_prophdl_t target_proph; /* "TargetTemp" property handle */ } sensor_node_t; /* * Sensor nodes array */ static sensor_node_t sensor_nodes[] = { {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58", SENSOR_CPU0_DIE, NULL, 0, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58", SENSOR_CPU1_DIE, NULL, 0, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58", SENSOR_INT_AMB_0, NULL, 0, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c", SENSOR_SYS_OUT, NULL, 0, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c", SENSOR_SYS_IN, NULL, 0, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c", SENSOR_INT_AMB_1, NULL, 0, 0, 0}, }; #define N_SENSOR_NODES (sizeof (sensor_nodes)/sizeof (sensor_nodes[0])) /* * Fan node data structure */ typedef struct { char *parent_path; /* parent node path */ char *fan_name; /* fan name */ env_fan_t *fanp; /* fan information */ char *speed_unit; /* speed unit string */ picl_nodehdl_t nodeh; /* "fan" node handle */ picl_prophdl_t proph; /* "Speed" property handle */ } fan_node_t; /* * Fan node array */ static fan_node_t fan_nodes[] = { {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58", ENV_CPU0_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58", ENV_CPU1_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c", ENV_SYSTEM_OUT_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c", ENV_SYSTEM_INTAKE_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, 0, 0}, {"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,52", ENV_DIMM_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, 0, 0}, }; #define N_FAN_NODES (sizeof (fan_nodes)/sizeof (fan_nodes[0])) /* * Disk node data structure */ typedef struct { char *parent_path; /* parent node path */ char *disk_name; /* disk name */ env_disk_t *diskp; /* disk information */ picl_nodehdl_t nodeh; /* "disk" node handle */ picl_prophdl_t proph; /* "Temperature" property handle */ } disk_node_t; /* * Disk node array */ static disk_node_t disk_nodes[] = { {DISK0_NODE_PATH, ENV_DISK0, NULL, 0, 0}, {DISK1_NODE_PATH, ENV_DISK1, NULL, 0, 0}, }; #define N_DISK_NODES (sizeof (disk_nodes)/sizeof (disk_nodes[0])) /* * Miscellaneous declarations */ static void delete_sensor_nodes_and_props(void); static void delete_disk_nodes_and_props(void); static void delete_fan_nodes_and_props(void); /* * Read function for volatile "Temperature" property */ static int get_current_temp(ptree_rarg_t *parg, void *buf) { tempr_t temp; picl_prophdl_t proph; sensor_node_t *snodep; int i; /* * Locate the sensor in our sensor_nodes table by matching the * property handle and get its temperature. */ proph = parg->proph; for (i = 0; i < N_SENSOR_NODES; ++i) { snodep = &sensor_nodes[i]; if (snodep->proph != proph) continue; if (get_temperature(snodep->sensorp, &temp) < 0) break; (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t)); return (PICL_SUCCESS); } return (PICL_FAILURE); } /* * Read function for volatile "Temperature" property */ static int get_disk_temp(ptree_rarg_t *parg, void *buf) { tempr_t temp; picl_prophdl_t proph; disk_node_t *dnodep; int i; /* * Locate the sensor in our sensor_nodes table by matching the * property handle and get its temperature. */ proph = parg->proph; for (i = 0; i < N_DISK_NODES; ++i) { dnodep = &disk_nodes[i]; if (dnodep->proph != proph) continue; if (disk_temperature(dnodep->diskp, &temp) < 0) break; (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t)); return (PICL_SUCCESS); } return (PICL_FAILURE); } /* * Read function for volatile "Speed" property on "fan" class node */ static int set_current_speed(ptree_warg_t *parg, const void *buf) { fanspeed_t speed; picl_prophdl_t proph; fan_node_t *fnodep; int i, ret; /* * Locate the fan in our fan_nodes table by matching the * property handle and get fan speed. */ proph = parg->proph; for (i = 0; i < N_FAN_NODES; ++i) { fnodep = &fan_nodes[i]; if (fnodep->proph != proph) continue; if (fnodep->fanp->fd == -1) continue; (void) memcpy((caddr_t)&speed, buf, sizeof (speed)); ret = set_fan_speed(fnodep->fanp, speed); if (ret < 0) { if (ret == -1 && errno == EBUSY) return (PICL_NOTWRITABLE); if (ret == -2) return (PICL_INVALIDARG); break; } return (PICL_SUCCESS); } return (PICL_FAILURE); } /* * Read function for volatile "Speed" property on "fan" class node */ static int get_current_speed(ptree_rarg_t *parg, void *buf) { fanspeed_t speed; picl_prophdl_t proph; fan_node_t *fnodep; int i; /* * Locate the fan in our fan_nodes table by matching the * property handle and get fan speed. */ proph = parg->proph; for (i = 0; i < N_FAN_NODES; ++i) { fnodep = &fan_nodes[i]; if (fnodep->proph != proph) continue; if (fnodep->fanp->fd == -1) continue; if (get_fan_speed(fnodep->fanp, &speed) < 0) break; (void) memcpy(buf, (caddr_t)&speed, sizeof (speed)); return (PICL_SUCCESS); } return (PICL_FAILURE); } /* * Create and add the specified regular property */ static int add_regular_prop(picl_nodehdl_t nodeh, char *name, int type, int access, int size, void *valbuf, picl_prophdl_t *prophp) { int err; ptree_propinfo_t propinfo; picl_prophdl_t proph; err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION, type, access, size, name, NULL, NULL); if (err != PICL_SUCCESS) return (err); err = ptree_create_and_add_prop(nodeh, &propinfo, valbuf, &proph); if (err == PICL_SUCCESS && prophp) *prophp = proph; return (err); } /* * Create and add the specified volatile property */ static int add_volatile_prop(picl_nodehdl_t nodeh, char *name, int type, int access, int size, ptree_vol_rdfunc_t *rdfunc, ptree_vol_wrfunc_t *wrfunc, picl_prophdl_t *prophp) { int err; ptree_propinfo_t propinfo; picl_prophdl_t proph; err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION, type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc); if (err != PICL_SUCCESS) return (err); err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph); if (err == PICL_SUCCESS && prophp) *prophp = proph; return (err); } /* * Add temperature threshold properties */ static void add_sensor_thresh_props(picl_nodehdl_t nodeh, sensor_ctrl_blk_t *threshp) { picl_prophdl_t proph; (void) add_regular_prop(nodeh, PICL_PROP_LOW_POWER_OFF, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->low_power_off), (void *)&(threshp->low_power_off), &proph); (void) add_regular_prop(nodeh, PICL_PROP_LOW_SHUTDOWN, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->low_shutdown), (void *)&(threshp->low_shutdown), &proph); (void) add_regular_prop(nodeh, PICL_PROP_LOW_WARNING, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->low_warning), (void *)&(threshp->low_warning), &proph); (void) add_regular_prop(nodeh, PICL_PROP_HIGH_WARNING, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->high_warning), (void *)&(threshp->high_warning), &proph); (void) add_regular_prop(nodeh, PICL_PROP_HIGH_SHUTDOWN, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->high_shutdown), (void *)&(threshp->high_shutdown), &proph); (void) add_regular_prop(nodeh, PICL_PROP_HIGH_POWER_OFF, PICL_PTYPE_INT, PICL_READ, sizeof (threshp->high_power_off), (void *)&(threshp->high_power_off), &proph); } /* * Go through the sensor_nodes array and create those nodes * and the Temperature property to report the temperature. */ static int add_sensor_nodes_and_props() { int err; char *pname, *nodename, *devfs_path; sensor_node_t *snodep; sensor_ctrl_blk_t *threshp; picl_nodehdl_t nodeh, cnodeh; picl_prophdl_t proph; env_sensor_t *sensorp; int i; for (i = 0; i < N_SENSOR_NODES; ++i) { snodep = &sensor_nodes[i]; /* * Get the parent nodeh */ err = ptree_get_node_by_path(snodep->parent_path, &nodeh); if (err != PICL_SUCCESS) continue; sensorp = snodep->sensorp; if (sensorp->present == B_FALSE) continue; /* * Create temperature-sensor node */ nodename = snodep->sensor_name; err = ptree_create_and_add_node(nodeh, nodename, PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh); if (env_debug) envd_log(LOG_INFO, "Creating PICL sensor node '%s' err:%d\n", nodename, err); if (err != PICL_SUCCESS) break; /* save node handle */ snodep->nodeh = cnodeh; /* * Add "devfs_path" property in child node */ devfs_path = sensorp->devfs_path; pname = PICL_PROP_DEVFS_PATH; err = add_regular_prop(cnodeh, pname, PICL_PTYPE_CHARSTRING, PICL_READ, strlen(devfs_path)+1, (void *)devfs_path, &proph); if (err != PICL_SUCCESS) break; /* * Now add volatile "temperature" volatile property * in this "temperature-sensor" class node. */ pname = PICL_PROP_TEMPERATURE; err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t), get_current_temp, NULL, &proph); if (err != PICL_SUCCESS) break; /* Save prop handle */ snodep->proph = proph; /* * Add threshold related properties */ threshp = sensorp->es_ptr; if (threshp != NULL) add_sensor_thresh_props(cnodeh, threshp); } if (err != PICL_SUCCESS) { delete_sensor_nodes_and_props(); if (env_debug) envd_log(LOG_INFO, "Can't create prop/node for sensor '%s'\n", nodename); return (err); } return (PICL_SUCCESS); } /* * Delete all sensor nodes and related properties created by the * add_sensor_prop() for each sensor node in the PICL tree. */ static void delete_sensor_nodes_and_props(void) { sensor_node_t *snodep; int i; /* * Delete/destroy any property created in the sensed device * as well as the sensor node and all properties under it. * Note that deleiing/destroying a node deletes/destroys * all properties within that node. */ for (i = 0; i < N_SENSOR_NODES; ++i) { snodep = &sensor_nodes[i]; if (snodep->nodeh != 0) { /* delete node and all properties under it */ (void) ptree_delete_node(snodep->nodeh); (void) ptree_destroy_node(snodep->nodeh); snodep->nodeh = 0; snodep->proph = 0; } } } /* * Go through the disk_nodes array and create those nodes * and the Temperature property to report the temperature. */ static int add_disk_nodes_and_props() { int err; char *pname, *nodename, *devfs_path; disk_node_t *dnodep; picl_nodehdl_t nodeh, cnodeh; picl_prophdl_t proph; env_disk_t *diskp; int i; for (i = 0; i < N_DISK_NODES; ++i) { dnodep = &disk_nodes[i]; /* * Get the parent nodeh */ err = ptree_get_node_by_path(dnodep->parent_path, &nodeh); if (err != PICL_SUCCESS) { if (env_debug) envd_log(LOG_ERR, "failed to get node for path %s\n", dnodep->parent_path); err = PICL_SUCCESS; continue; } diskp = dnodep->diskp; if (diskp->present == B_FALSE) continue; /* * Create temperature-sensor node */ nodename = dnodep->disk_name; err = ptree_create_and_add_node(nodeh, nodename, PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh); if (env_debug) envd_log(LOG_ERR, "Creating PICL disk node '%s' err:%d\n", nodename, err); if (err != PICL_SUCCESS) break; /* save node handle */ dnodep->nodeh = cnodeh; /* * Add "devfs_path" property in child node */ devfs_path = diskp->devfs_path; pname = PICL_PROP_DEVFS_PATH; err = add_regular_prop(cnodeh, pname, PICL_PTYPE_CHARSTRING, PICL_READ, strlen(devfs_path)+1, (void *)devfs_path, &proph); if (err != PICL_SUCCESS) break; /* * Now add volatile "temperature" volatile property * in this "temperature-sensor" class node. */ pname = PICL_PROP_TEMPERATURE; err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t), get_disk_temp, NULL, &proph); if (err != PICL_SUCCESS) break; /* Save prop handle */ dnodep->proph = proph; /* * Add threshold related properties */ (void) add_regular_prop(cnodeh, PICL_PROP_LOW_SHUTDOWN, PICL_PTYPE_INT, PICL_READ, sizeof (diskp->low_shutdown), (void *)&(diskp->low_shutdown), &proph); (void) add_regular_prop(cnodeh, PICL_PROP_LOW_WARNING, PICL_PTYPE_INT, PICL_READ, sizeof (diskp->low_warning), (void *)&(diskp->low_warning), &proph); (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_WARNING, PICL_PTYPE_INT, PICL_READ, sizeof (diskp->high_warning), (void *)&(diskp->high_warning), &proph); (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_SHUTDOWN, PICL_PTYPE_INT, PICL_READ, sizeof (diskp->high_shutdown), (void *)&(diskp->high_shutdown), &proph); } if (err != PICL_SUCCESS) { delete_disk_nodes_and_props(); if (env_debug) envd_log(LOG_INFO, "Can't create prop/node for disk '%s'\n", nodename); return (err); } return (PICL_SUCCESS); } /* * Delete all disk nodes and related properties created by the * add_disk_props() for each disk node in the PICL tree. */ static void delete_disk_nodes_and_props(void) { disk_node_t *dnodep; int i; /* * Delete/destroy disk node and all properties under it. * Note that deleting/destroying a node deletes/destroys * all properties within that node. */ for (i = 0; i < N_DISK_NODES; ++i) { dnodep = &disk_nodes[i]; if (dnodep->nodeh != 0) { (void) ptree_delete_node(dnodep->nodeh); (void) ptree_destroy_node(dnodep->nodeh); dnodep->nodeh = 0; dnodep->proph = 0; } } } /* * For each entry in fan_nodes[] array, do the following: * - Create specified "fan" class node. * - Create "Speed" volatile propery under "fan" class node. * - Create "SpeedUnit" property under "fan" class node. */ static int add_fan_nodes_and_props() { int err; char *pname, *nodename, *devfs_path; env_fan_t *fanp; fan_node_t *fnodep; picl_nodehdl_t nodeh, cnodeh; picl_prophdl_t proph; int i; for (i = 0; i < N_FAN_NODES; ++i) { /* * Add various fan nodes and properties */ fnodep = &fan_nodes[i]; if (fnodep->fanp->present == B_FALSE) continue; /* * get parent nodeh */ err = ptree_get_node_by_path(fnodep->parent_path, &nodeh); if (err != PICL_SUCCESS) { if (env_debug) envd_log(LOG_ERR, "node for %s NOT FOUND.\n", fnodep->parent_path); err = PICL_SUCCESS; continue; } /* * Create "fan" class node and save node handle */ nodename = fnodep->fan_name; err = ptree_create_and_add_node(nodeh, nodename, PICL_CLASS_FAN, &cnodeh); if (env_debug) envd_log(LOG_ERR, "Creating PICL fan node '%s' err:%d\n", nodename, err); if (err != PICL_SUCCESS) break; fnodep->nodeh = cnodeh; /* * Add "devfs_path" property in child node */ fanp = fnodep->fanp; devfs_path = fanp->devfs_path; pname = PICL_PROP_DEVFS_PATH; err = add_regular_prop(cnodeh, pname, PICL_PTYPE_CHARSTRING, PICL_READ, strlen(devfs_path)+1, (void *)devfs_path, &proph); if (err != PICL_SUCCESS) break; /* * Add "Speed" volatile property in this "fan" * class node and save prop handle. */ pname = PICL_PROP_FAN_SPEED; if (fanp->id == DIMM_FAN_ID) { /* * We do not permit setting of DIMM FAN speeds. */ err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT, PICL_READ, sizeof (fanspeed_t), get_current_speed, NULL, &proph); } else { err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT, PICL_READ|PICL_WRITE, sizeof (fanspeed_t), get_current_speed, set_current_speed, &proph); } if (err != PICL_SUCCESS) break; fnodep->proph = proph; /* * Add other "fan" class properties */ pname = PICL_PROP_FAN_SPEED_UNIT; err = add_regular_prop(cnodeh, pname, PICL_PTYPE_CHARSTRING, PICL_READ, strlen(fnodep->speed_unit)+1, (void *)fnodep->speed_unit, &proph); if (err != PICL_SUCCESS) break; } if (err != PICL_SUCCESS) { delete_fan_nodes_and_props(); if (env_debug) envd_log(LOG_WARNING, "Can't create prop/node for fan '%s'\n", nodename); return (err); } return (PICL_SUCCESS); } /* * Delete all fan nodes and related properties created by the * add_fan_props() for each fan node in the PICL tree. */ static void delete_fan_nodes_and_props(void) { fan_node_t *fnodep; int i; /* * Delete/destroy fan node and all properties under it. * Note that deleting/destroying a node deletes/destroys * all properties within that node. */ for (i = 0; i < N_FAN_NODES; ++i) { fnodep = &fan_nodes[i]; if (fnodep->nodeh != 0) { (void) ptree_delete_node(fnodep->nodeh); (void) ptree_destroy_node(fnodep->nodeh); fnodep->nodeh = 0; } } } /* * Tuneables publishing functions */ static int copy_persistent_tuneable(env_tuneable_t *tune, char *buf) { switch (tune->type) { case PICL_PTYPE_INT : { (void) memcpy((int *)tune->value, buf, tune->nbytes); break; } case PICL_PTYPE_CHARSTRING : { (void) memcpy((caddr_t)tune->value, buf, tune->nbytes); break; } default : { return (PICL_FAILURE); } } return (PICL_SUCCESS); } static void env_parse_tunables(picl_nodehdl_t rooth) { char nmbuf[SYS_NMLN]; char pname[PATH_MAX]; if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) { (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf); (void) strlcat(pname, TUNABLE_CONF_FILE, PATH_MAX); if (access(pname, R_OK) == 0) { (void) picld_pluginutil_parse_config_file(rooth, pname); return; } } } int env_picl_setup_tuneables(void) { int err; int i; picl_nodehdl_t nodeh; picl_nodehdl_t rooth; picl_prophdl_t proph; env_tuneable_t *tuneablep; char read_buf[BUFSIZ]; if (ptree_get_root(&rooth) != PICL_SUCCESS) { return (PICL_FAILURE); } err = ptree_create_and_add_node(rooth, PICL_PLUGINS_NODE, PICL_CLASS_PICL, &nodeh); if (err != PICL_SUCCESS) return (PICL_FAILURE); err = ptree_create_and_add_node(nodeh, PICL_ENVIRONMENTAL_NODE, PICL_CLASS_PICL, &nodeh); if (err != PICL_SUCCESS) { return (PICL_FAILURE); } /* * Parse the conf file */ env_parse_tunables(rooth); for (i = 0; i < ntuneables; i++) { tuneablep = &tuneables[i]; err = ptree_get_propval_by_name(nodeh, tuneablep->name, read_buf, tuneablep->nbytes); if (err != PICL_SUCCESS) { /* * Add volitle functions to environmental node */ err = add_volatile_prop(nodeh, tuneablep->name, tuneablep->type, PICL_READ|PICL_WRITE, tuneablep->nbytes, tuneablep->rfunc, tuneablep->wfunc, &proph); tuneablep->proph = proph; } else { /* * property is persistent */ (void) copy_persistent_tuneable(tuneablep, read_buf); } } return (PICL_SUCCESS); } /* * Find the ENVMODEL_CONF_FILE file. */ static int get_envmodel_conf_file(char *outfilename) { char nmbuf[SYS_NMLN]; char pname[PATH_MAX]; if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) { (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf); (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX); if (access(pname, R_OK) == 0) { (void) strlcpy(outfilename, pname, PATH_MAX); return (0); } } if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) { (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf); (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX); if (access(pname, R_OK) == 0) { (void) strlcpy(outfilename, pname, PATH_MAX); return (0); } } (void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR, ENV_CONF_FILE); if (access(pname, R_OK) == 0) { (void) strlcpy(outfilename, pname, PATH_MAX); return (0); } return (-1); } /* Delete all sensor/fan nodes and any properties created by this plugin */ void env_picl_destroy(void) { delete_fan_nodes_and_props(); delete_sensor_nodes_and_props(); delete_disk_nodes_and_props(); } void env_picl_setup(void) { int err; sensor_node_t *snodep; fan_node_t *fnodep; disk_node_t *dnodep; picl_nodehdl_t plath; char fullfilename[PATH_MAX]; picl_nodehdl_t rooth; int i; /* * Initialize sensorp and other fields in the sensor_nodes[] array */ for (i = 0; i < N_SENSOR_NODES; ++i) { snodep = &sensor_nodes[i]; snodep->sensorp = sensor_lookup(snodep->sensor_name); snodep->nodeh = 0; snodep->proph = 0; snodep->target_proph = 0; } /* * Initialize fanp and other fields in the fan_nodes[] array */ for (i = 0; i < N_FAN_NODES; ++i) { fnodep = &fan_nodes[i]; fnodep->fanp = fan_lookup(fnodep->fan_name); fnodep->nodeh = 0; fnodep->proph = 0; } /* * Initialize diskp and other fields in the disk_nodes[] array */ for (i = 0; i < N_DISK_NODES; ++i) { dnodep = &disk_nodes[i]; dnodep->diskp = disk_lookup(dnodep->disk_name); dnodep->nodeh = 0; dnodep->proph = 0; } /* * Get platform handle and populate PICL tree with environmental * nodes and properties */ err = ptree_get_node_by_path("/platform", &plath); if (err == PICL_SUCCESS) err = add_sensor_nodes_and_props(); if (err == PICL_SUCCESS) err = add_fan_nodes_and_props(); if ((err == PICL_SUCCESS) && (monitor_disk_temp)) err = add_disk_nodes_and_props(); /* * We can safely call delete_xxx_nodes_and_props even * if nodes were not added. */ if (err != PICL_SUCCESS) { delete_fan_nodes_and_props(); delete_disk_nodes_and_props(); delete_sensor_nodes_and_props(); envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED); return; } /* * Parse the envmodel.conf file and populate the PICL tree */ if (get_envmodel_conf_file(fullfilename) < 0) envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED); if (ptree_get_root(&rooth) != PICL_SUCCESS) envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED); err = picld_pluginutil_parse_config_file(rooth, fullfilename); if (err != PICL_SUCCESS) envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED); }