excalibur/envd/piclenvsetup.c

	piclenvsetup.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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 (c) 1999-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

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

/*
 * This file contains code for setting up environmental related nodes
 * and properties in the PICL tree.
 *
 * For each temperature-device class node, it does the following:
 *  - Create cpu and cpu-ambient temperautre-sensor class nodes.
 *  - Create "devfs-path" property under each temperature-sensor class node
 *  - Create "Temperature" volatile property under these nodes.
 *  - Create various temperature threshold properties under each node.
 *  - Create "Temperature" and "AmbientTemperature" volatile properties
 *    under corresponding "cpu" class node.
 *
 * For the "fan-control" node, it does the following:
 *  - Create system-fan node
 *  - Create "devfs-path" property under "fan" class node
 *  - Create "Speed" volatile propery under each node.
 *  - Create "SpeedUnit" property under each node.
 *
 * Access to sensor/fan properties is protected by the envpicl_rwlock
 * readers/writer lock. This lock is held as a reader while trying to
 * access any volatile sensor/fan property, and held as a writer lock
 * while trying to create or destroy sensor/fan nodes and properties.
 */

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <syslog.h>
#include <stdlib.h>
#include <limits.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);

#define PROP_FAN_SPEED_UNIT_VALUE   "%"

/*
 * PICL class path for CPU nodes
 */
#define CPU0_PLAT_PATH      "_class:/gptwo/cpu?ID=0"
#define CPU1_PLAT_PATH      "_class:/gptwo/cpu?ID=1"

/*
 * "UnitAddress" propval for various temperature devices (platform dependent)
 */
#define CPU0_TEMPDEV_UNITADDR   "0,30"
#define CPU1_TEMPDEV_UNITADDR   "0,98"

/*
 * Sensor node data structure
 */
typedef struct {
    char        *sensor_name;   /* sensor name */
    env_sensor_t    *sensorp;   /* sensor info */
    char        *unitaddr;  /* parent's UnitAddress propval */
    char        *sdev_node; /* sensed device node name */
    char        *sdev_pname;    /* sensed device "temp" prop name */
    picl_nodehdl_t  nodeh;      /* sensor node handle */
    picl_prophdl_t  proph;      /* "Temperature" property handle */
    picl_prophdl_t  target_proph;   /* "TargetTemp" property handle */
    picl_prophdl_t  sdev_proph; /* property handle for sensed dev */
} sensor_node_t;


/*
 * Sensor nodes array
 */
static sensor_node_t sensor_nodes[] = {
    {SENSOR_CPU0_DIE, NULL, CPU0_TEMPDEV_UNITADDR,
        CPU0_PLAT_PATH, PICL_PROP_CPU_DIE_TEMP},

    {SENSOR_CPU0_AMB, NULL, CPU0_TEMPDEV_UNITADDR,
        CPU0_PLAT_PATH, PICL_PROP_CPU_AMB_TEMP},

    {SENSOR_CPU1_DIE, NULL, CPU1_TEMPDEV_UNITADDR,
        CPU1_PLAT_PATH, PICL_PROP_CPU_DIE_TEMP},

    {SENSOR_CPU1_AMB, NULL, CPU1_TEMPDEV_UNITADDR,
        CPU1_PLAT_PATH, PICL_PROP_CPU_AMB_TEMP},

    {NULL, NULL, NULL, NULL, NULL}
};


/*
 * Fan node data structure
 */
typedef struct {
    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[] =  {
    {ENV_SYSTEM_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
    {ENV_CPU_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
    {ENV_PSUPPLY_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
    {NULL, NULL, NULL}
};


/*
 * Miscellaneous declarations
 */
typedef struct node_list {
    picl_nodehdl_t      nodeh;
    struct node_list    *next;
} node_list_t;

static void delete_sensor_nodes_and_props(void);
static void delete_fan_nodes_and_props(void);
static pthread_rwlock_t envpicl_rwlock = PTHREAD_RWLOCK_INITIALIZER;


/*
 * Read function for volatile "Temperature" property
 */
static int
get_current_target_temp(ptree_rarg_t *parg, void *buf)
{
    picl_prophdl_t  proph;
    sensor_node_t   *snodep;
    env_sensor_t    *sensorp;

    /*
     * Locate the sensor in our sensor_nodes table by matching the
     * property handle and get its temperature.
     */
    proph = parg->proph;
    (void) pthread_rwlock_rdlock(&envpicl_rwlock);
    for (snodep = &sensor_nodes[0]; snodep->sensor_name != NULL;
        snodep++) {
        if (snodep->target_proph != proph)
            continue;

        if ((sensorp = snodep->sensorp) == NULL)
            break;
        (void) memcpy(buf, (caddr_t)&sensorp->target_temp,
            sizeof (sensorp->target_temp));
        (void) pthread_rwlock_unlock(&envpicl_rwlock);
        return (PICL_SUCCESS);
    }
    (void) pthread_rwlock_unlock(&envpicl_rwlock);
    return (PICL_FAILURE);
}


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

    /*
     * Locate the sensor in our sensor_nodes table by matching the
     * property handle and get its temperature.
     */
    proph = parg->proph;
    (void) pthread_rwlock_rdlock(&envpicl_rwlock);
    for (snodep = &sensor_nodes[0]; snodep->sensor_name != NULL;
        snodep++) {
        if (snodep->proph != proph &&
            snodep->sdev_proph != proph)
            continue;

        if (get_temperature(snodep->sensorp, &temp) < 0)
            break;
        (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
        (void) pthread_rwlock_unlock(&envpicl_rwlock);
        return (PICL_SUCCESS);
    }
    (void) pthread_rwlock_unlock(&envpicl_rwlock);
    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;

    /*
     * Locate the fan in our fan_nodes table by matching the
     * property handle and get fan speed.
     */
    proph = parg->proph;
    (void) pthread_rwlock_rdlock(&envpicl_rwlock);
    for (fnodep = &fan_nodes[0]; fnodep->fan_name != NULL; fnodep++) {
        if (fnodep->proph != proph)
            continue;
        if (get_fan_speed(fnodep->fanp, &speed) < 0)
            break;
        speed = (fanspeed_t)(speed * 100/fnodep->fanp->speed_max);

        (void) memcpy(buf, (caddr_t)&speed, sizeof (speed));
        (void) pthread_rwlock_unlock(&envpicl_rwlock);
        return (PICL_SUCCESS);
    }
    (void) pthread_rwlock_unlock(&envpicl_rwlock);
    return (PICL_FAILURE);
}


static node_list_t *
add_node_to_list(picl_nodehdl_t nodeh, node_list_t *listp)
{
    node_list_t *el;
    node_list_t *tmp;

    el = malloc(sizeof (node_list_t));
    if (el == NULL)
        return (listp);
    el->nodeh = nodeh;
    el->next = NULL;
    if (listp == NULL) {
        listp = el;
        return (listp);
    }

    /*
     * append to the end to preserve the order found
     */
    tmp = listp;
    while (tmp->next != NULL)
        tmp = tmp->next;

    tmp->next = el;
    return (listp);
}


/*
 * Get a list of nodes of the specified classname under nodeh
 * Once a node of the specified class is found, it's children are not
 * searched.
 */
static node_list_t *
get_node_list_by_class(picl_nodehdl_t nodeh, const char *classname,
    node_list_t *listp)
{
    int     err;
    char        clname[PICL_CLASSNAMELEN_MAX+1];
    picl_nodehdl_t  chdh;

    /*
     * go through the children
     */
    err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
        sizeof (picl_nodehdl_t));

    while (err == PICL_SUCCESS) {
        err = ptree_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
            clname, strlen(classname) + 1);

        if ((err == PICL_SUCCESS) && (strcmp(clname, classname) == 0))
            listp = add_node_to_list(chdh, listp);
        else
            listp = get_node_list_by_class(chdh, classname, listp);

        err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
            sizeof (picl_nodehdl_t));
    }
    return (listp);
}


/*
 * Free memory allocated to build the specified node list.
 */
static void
free_node_list(node_list_t *listp)
{
    node_list_t *next;

    for (; listp != NULL; listp = next) {
        next = listp->next;
        free(listp);
    }
}

/*
 * Get PICL_PTYPE_CHARSTRING "UnitAddress" property
 */
static int
get_unit_address_prop(picl_nodehdl_t nodeh, void *buf, size_t len)
{
    int         err;
    picl_prophdl_t      proph;
    ptree_propinfo_t    pinfo;

    err = ptree_get_prop_by_name(nodeh, PICL_PROP_UNIT_ADDRESS, &proph);
    if (err == PICL_SUCCESS)
        err = ptree_get_propinfo(proph, &pinfo);

    if (err != PICL_SUCCESS)
        return (err);

    if (pinfo.piclinfo.type != PICL_PTYPE_CHARSTRING ||
        pinfo.piclinfo.size > len)
        return (PICL_FAILURE);

    err = ptree_get_propval(proph, buf, pinfo.piclinfo.size);
    return (err);
}


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


/*
 * Lookup "temperature-device" class nodes and create "temperature-sensor"
 * class nodes and relevant properties under those nodes.
 *
 * For each entry in sensor_nodes[] array, do the following:
 *  - Create specified (cpu-die or cpu-ambient) "temperautre-sensor" class
 *    node.
 *  - Create "devfs-path" property under this node.
 *  - Create "Temperature" volatile property under this node.
 *  - Create various temperature threshold properties under this node.
 *  - Create specified ("Temperature" or "AmbientTemperature") volatile
 *    temperature property under specified sdev_node node.
 */

static int
add_sensor_nodes_and_props(picl_nodehdl_t plath)
{
    int     err;
    char        *pname, *nodename, *refnode, *devfs_path;
    node_list_t *node_list, *listp;
    sensor_node_t   *snodep;
    sensor_thresh_t *threshp;
    picl_nodehdl_t  nodeh, refnodeh, cnodeh;
    picl_prophdl_t  proph;
    char        unitaddr[PICL_UNITADDR_LEN_MAX];
    env_sensor_t    *sensorp;

    node_list =
        get_node_list_by_class(plath, PICL_CLASS_TEMPERATURE_DEVICE, NULL);

    if (node_list == NULL)
        return (PICL_FAILURE);

    for (listp = node_list; listp != NULL; listp = listp->next) {
        /*
         * Get "reg" property. Skip if no "reg" property found.
         */
        nodeh = listp->nodeh;
        err = get_unit_address_prop(nodeh, (void *)unitaddr,
            sizeof (unitaddr));
        if (err != PICL_SUCCESS)
            continue;

        for (snodep = sensor_nodes; snodep->sensor_name != NULL;
            snodep++) {

            /* Match "UnitAddress" property */
            if (strcasecmp(unitaddr, snodep->unitaddr) != 0)
                continue;

            /*
             * Skip if already initialized or no sensor info
             */
            sensorp = snodep->sensorp;
            if (snodep->nodeh != NULL || sensorp == NULL)
                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->temp_thresh;
            if (threshp && threshp->policy_type ==
                POLICY_TARGET_TEMP) {
                /*
                 * Add volatile "TargetTemperature" property
                 */
                pname = PICL_PROP_TARGET_TEMPERATURE;
                err = add_volatile_prop(cnodeh, pname,
                    PICL_PTYPE_INT, PICL_READ,
                    sizeof (sensorp->target_temp),
                    get_current_target_temp, NULL, &proph);
                if (err != PICL_SUCCESS)
                    break;
                snodep->target_proph = proph;
            }

            if (threshp != NULL)
                add_sensor_thresh_props(cnodeh, threshp);

            /*
             * Finally create property in the sensed device
             * (if one specified)
             */
            refnode =  snodep->sdev_node;
            pname =  snodep->sdev_pname;
            if (refnode == NULL || pname == NULL)
                continue;

            err = ptree_get_node_by_path(refnode, &refnodeh);
            if (err == PICL_SUCCESS) {
                err = add_volatile_prop(refnodeh, pname,
                    PICL_PTYPE_INT, PICL_READ,
                    sizeof (tempr_t), get_current_temp,
                    NULL, &proph);
            }

            if (err != PICL_SUCCESS)
                break;

            /* Save prop handle */
            snodep->sdev_proph = proph;
        }
        if (err != PICL_SUCCESS) {
            delete_sensor_nodes_and_props();
            free_node_list(node_list);
            if (env_debug)
                envd_log(LOG_INFO,
                    "Can't create prop/node for sensor '%s'\n",
                    nodename);
            return (err);
        }
    }

    free_node_list(node_list);
    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;

    /*
     * 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 (snodep = sensor_nodes; snodep->sensor_name != NULL; snodep++) {
        if (snodep->sdev_proph != NULL) {
            (void) ptree_delete_prop(snodep->sdev_proph);
            (void) ptree_destroy_prop(snodep->sdev_proph);
            snodep->sdev_proph = NULL;
        }

        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;
        }
    }
}


/*
 * Lookup "fan-control" class node and create "fan" class nodes and
 * relevant properties under those nodes.
 *
 * For each entry in fan_nodes[] array, do the following:
 *  - Create specified "fan" class node.
 *  - Create "devfs-path" property under "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(picl_nodehdl_t plath)
{
    int     err;
    char        *pname, *nodename, *devfs_path;
    env_fan_t   *fanp;
    fan_node_t  *fnodep;
    picl_nodehdl_t  nodeh, cnodeh;
    picl_prophdl_t  proph;
    node_list_t *node_list, *listp;

    node_list =
        get_node_list_by_class(plath, PICL_CLASS_FAN_CONTROL, NULL);

    if (node_list == NULL)
        return (PICL_FAILURE);

    for (listp = node_list; listp != NULL; listp = listp->next) {
        /*
         * Add various fan nodes and properties
         */
        nodeh = listp->nodeh;
        err = PICL_SUCCESS;
        for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {

            /* Skip if already initialized or no fan info */
            if (fnodep->nodeh != NULL || fnodep->fanp == NULL)
                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_INFO,
                    "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;
            err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT,
                PICL_READ, sizeof (fanspeed_t), get_current_speed,
                NULL, &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();
            free_node_list(node_list);
            if (env_debug)
                envd_log(LOG_WARNING,
                    "Can't create prop/node for fan '%s'\n",
                    nodename);
            return (err);
        }
    }

    free_node_list(node_list);
    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;

    /*
     * Delete/destroy fan node and all properties under it.
     * Note that deleiing/destroying a node deletes/destroys
     * all properties within that node.
     */

    for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {
        if (fnodep->nodeh != NULL) {
            (void) ptree_delete_node(fnodep->nodeh);
            (void) ptree_destroy_node(fnodep->nodeh);
            fnodep->nodeh = NULL;
        }
    }
}

/*
 * 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, ENVMODEL_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, ENVMODEL_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,
        ENVMODEL_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)
{
    (void) pthread_rwlock_wrlock(&envpicl_rwlock);
    delete_fan_nodes_and_props();
    delete_sensor_nodes_and_props();
    (void) pthread_rwlock_unlock(&envpicl_rwlock);
}

void
env_picl_setup(void)
{
    int     err;
    sensor_node_t   *snodep;
    fan_node_t  *fnodep;
    picl_nodehdl_t  plath;
    char        fullfilename[PATH_MAX];
    picl_nodehdl_t  rooth;


    /*
     * Initialize sensorp and other fields in the sensor_nodes[] array
     */
    for (snodep = sensor_nodes; snodep->sensor_name != NULL; snodep++) {
        snodep->sensorp = sensor_lookup(snodep->sensor_name);
        snodep->nodeh = NULL;
        snodep->proph = NULL;
        snodep->target_proph = NULL;
        snodep->sdev_proph = NULL;
    }

    /*
     * Initialize fanp and other fields in the fan_nodes[] array
     */
    for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {
        fnodep->fanp = fan_lookup(fnodep->fan_name);
        fnodep->nodeh = NULL;
        fnodep->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) {
        (void) pthread_rwlock_wrlock(&envpicl_rwlock);
        err = add_sensor_nodes_and_props(plath);
        if (err == PICL_SUCCESS)
            err = add_fan_nodes_and_props(plath);

        if (err != PICL_SUCCESS)
            delete_sensor_nodes_and_props();
        (void) pthread_rwlock_unlock(&envpicl_rwlock);
    }

    if (err != PICL_SUCCESS) {
        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);
}