enchilada/envd/piclenvsetup.c

/*
 * 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.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * This file contains code for setting up environmental related nodes
 * and properties in the PICL tree.
 *
 */

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <syslog.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <sys/open.h>
#include <ctype.h>
#include <string.h>
#include <alloca.h>
#include <libintl.h>
#include <sys/systeminfo.h>
#include <picl.h>
#include <picltree.h>
#include <picld_pluginutil.h>
#include <pthread.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#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, NULL, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58",
	SENSOR_CPU1_DIE, NULL, NULL, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58",
	SENSOR_INT_AMB_0, NULL, NULL, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c",
	SENSOR_SYS_OUT, NULL, NULL, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c",
	SENSOR_SYS_IN, NULL, NULL, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c",
	SENSOR_INT_AMB_1, NULL, NULL, NULL, NULL},

};
#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, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,58",
	ENV_CPU1_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c",
	ENV_SYSTEM_OUT_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,5c",
	ENV_SYSTEM_INTAKE_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},

	{"/platform/pci@1e,600000/isa@7/i2c@0,320/hardware-monitor@0,52",
	ENV_DIMM_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},

};
#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, NULL, NULL},
	{DISK1_NODE_PATH, ENV_DISK1, NULL, NULL, NULL},
};
#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 != NULL) {
			/* delete node and all properties under it */
			(void) ptree_delete_node(snodep->nodeh);
			(void) ptree_destroy_node(snodep->nodeh);
			snodep->nodeh = NULL;
			snodep->proph = NULL;
		}
	}
}

/*
 * 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 != NULL) {
			(void) ptree_delete_node(dnodep->nodeh);
			(void) ptree_destroy_node(dnodep->nodeh);
			dnodep->nodeh = NULL;
			dnodep->proph = NULL;
		}
	}
}

/*
 * 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 != NULL) {
			(void) ptree_delete_node(fnodep->nodeh);
			(void) ptree_destroy_node(fnodep->nodeh);
			fnodep->nodeh = NULL;
		}
	}
}
/*
 * 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 = NULL;
		snodep->proph = NULL;
		snodep->target_proph = NULL;
	}

	/*
	 * 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 = NULL;
		fnodep->proph = NULL;
	}

	/*
	 * 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 = NULL;
		dnodep->proph = NULL;
	}

	/*
	 * 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);
}