snowbird/envmond/piclenvmond.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"

#include <unistd.h>
#include <picl.h>
#include <picltree.h>
#include <picldefs.h>
#include <pthread.h>
#include <syslog.h>
#include <string.h>
#include <libnvpair.h>
#include <libintl.h>
#include "piclenvmond.h"

/* external funcs and varaibles */
extern void env_handle_event(const char *, const void *, size_t);
extern picl_errno_t env_init();
extern void env_platmod_fini();
extern int sensor_fd;
extern pthread_t env_temp_thr_tid;

/* local defines */
#define TIMEOUT (10)

#pragma init(piclenvmond_register)

/*
 * Plugin registration entry points
 */
static void piclenvmond_register(void);
static void piclenvmond_init(void);
static void piclenvmond_fini(void);
static void piclenvmond_evhandler(const char *, const void *, size_t, void *);

int env_debug = 0x0;

static picld_plugin_reg_t envmond_reg_info = {
    PICLD_PLUGIN_VERSION_1,
    PICLD_PLUGIN_CRITICAL,
    "SUNW_piclenvmond",
    piclenvmond_init,
    piclenvmond_fini
};

typedef struct {
    picl_nodehdl_t nodehdl;
    char node_name[PICL_PROPNAMELEN_MAX];
} env_callback_args_t;

/*
 * picld entry points
 */
static void
piclenvmond_register(void)
{
    (void) picld_plugin_register(&envmond_reg_info);
}

/*
 * picld entry point
 *  - do all the initialization
 *  - register for interested picl events
 */
static void
piclenvmond_init(void)
{
    picl_errno_t rc = PICL_SUCCESS;

    if ((rc = env_init()) != PICL_SUCCESS) {
        syslog(LOG_ERR, gettext("SUNW_envmond:envmond init failed, "
            "error = %d"), rc);
        return;
    }

    /* register handler for state change events */
    (void) ptree_register_handler(PICLEVENT_STATE_CHANGE,
        piclenvmond_evhandler, NULL);
    /* register handler for condition change events */
    (void) ptree_register_handler(PICLEVENT_CONDITION_CHANGE,
        piclenvmond_evhandler, NULL);

}

static void
piclenvmond_fini(void)
{
    void        *exitval;

    /* unregister event handler */
    (void) ptree_unregister_handler(PICLEVENT_STATE_CHANGE,
        piclenvmond_evhandler, NULL);
    (void) ptree_unregister_handler(PICLEVENT_CONDITION_CHANGE,
        piclenvmond_evhandler, NULL);

    /* cancel all the threads */
    (void) pthread_cancel(env_temp_thr_tid);
    (void) pthread_join(env_temp_thr_tid, &exitval);

    /* do any platform specific cleanups required */
    env_platmod_fini();
    (void) close(sensor_fd);
}

/*ARGSUSED*/
static void
piclenvmond_evhandler(const char *ename, const void *earg, size_t size,
    void *cookie)
{
    env_handle_event(ename, earg, size);
}

/*
 * Utility functions
 */

/*
 * create_property -- Create a PICL property
 */
picl_errno_t
env_create_property(int ptype, int pmode, size_t psize, char *pname,
    int (*readfn)(ptree_rarg_t *, void *),
    int (*writefn)(ptree_warg_t *, const void *),
    picl_nodehdl_t nodeh, picl_prophdl_t *propp, void *vbuf)
{
    picl_errno_t        rc;     /* return code */
    ptree_propinfo_t    propinfo;   /* propinfo structure */
    picl_prophdl_t      proph;

    rc = ptree_get_prop_by_name(nodeh, pname, &proph);
    if (rc == PICL_SUCCESS) {   /* prop. already exists */
        return (rc);
    }

    rc = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
        ptype, pmode, psize, pname, readfn, writefn);
    if (rc != PICL_SUCCESS) {
        syslog(LOG_ERR, PTREE_INIT_PROPINFO_FAILED_MSG, rc);
        return (rc);
    }

    rc = ptree_create_and_add_prop(nodeh, &propinfo, vbuf, propp);
    if (rc != PICL_SUCCESS) {
        syslog(LOG_ERR, PTREE_CREATE_AND_ADD_PROP_FAILED_MSG, rc);
        return (rc);
    }
    return (PICL_SUCCESS);
}

/*
 * The picl event completion handler.
 */
/* ARGSUSED */
static void
event_completion_handler(char *ename, void *earg, size_t size)
{
    free(earg);
    free(ename);
}

/*
 * utility routine to post PICL events
 */
/*ARGSUSED*/
static int
post_picl_event(const char *ename, char *envl, size_t elen,
    picl_nodehdl_t nodeh, int cond_wait)
{
    nvlist_t    *nvlp;
    size_t      nvl_size;
    char        *pack_buf = NULL;
    char        *evname;

    if (nodeh == 0) {
        return (PICL_FAILURE);
    }
    if ((evname = strdup(ename)) == NULL)
        return (PICL_FAILURE);
    if (envl) {
        if (nvlist_unpack(envl, elen, &nvlp, 0) < 0) {
            nvlist_free(nvlp);
            free(evname);
            return (PICL_FAILURE);
        }
    } else {
        if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
            free(evname);
            return (PICL_FAILURE);
        }
    }

    if (nvlist_add_uint64(nvlp, PICLEVENTARG_NODEHANDLE, nodeh) == -1) {
        nvlist_free(nvlp);
        free(evname);
        return (PICL_FAILURE);
    }

    if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
        nvlist_free(nvlp);
        free(evname);
        return (PICL_FAILURE);
    }
    nvlist_free(nvlp);

    if (env_debug & EVENTS) {
        char enodename[PICL_PROPNAMELEN_MAX];
        if (ptree_get_propval_by_name(nodeh, PICL_PROP_NAME,
            enodename, sizeof (enodename)) == PICL_SUCCESS)
            syslog(LOG_INFO, "envmond:Posting %s on %s\n",
                ename, enodename);
    }

    if (ptree_post_event(evname, pack_buf, nvl_size,
        event_completion_handler) != 0) {
        syslog(LOG_ERR, gettext("SUNW_envmond: Error posting %s PICL"
            " event."), ename);
        free(pack_buf);
        free(evname);
        return (PICL_FAILURE);
    }
    return (PICL_SUCCESS);
}

/*
 * post dr_req events
 */
picl_errno_t
post_dr_req_event(picl_nodehdl_t fruh, char *dr_req_type, uint8_t wait)
{
    nvlist_t    *nvlp;  /* nvlist of event specific args */
    size_t      nvl_size;
    char        *pack_buf = NULL;
    char        dr_ap_id[PICL_PROPNAMELEN_MAX];
    int rc = PICL_SUCCESS;

    if (env_debug & DEBUG)
        syslog(LOG_DEBUG, "Post %s on %llx", dr_req_type, fruh);
    if (fruh == 0) {
        return (PICL_INVALIDARG);
    }
    if ((rc = ptree_get_propval_by_name(fruh, PICL_PROP_NAME,
        dr_ap_id, sizeof (dr_ap_id))) != PICL_SUCCESS) {
        return (rc);
    }

    if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
        return (PICL_FAILURE);
    }

    if (nvlist_add_string(nvlp, PICLEVENTARG_AP_ID, dr_ap_id) == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    if (nvlist_add_string(nvlp, PICLEVENTARG_DR_REQ_TYPE, dr_req_type)
        == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    nvlist_free(nvlp);

    if (env_debug & DEBUG)
        syslog(LOG_DEBUG, "Posting %s on %s", dr_req_type, dr_ap_id);
    rc = post_picl_event(PICLEVENT_DR_REQ, pack_buf, nvl_size, fruh,
        wait);

    free(pack_buf);
    return (rc);
}

/*
 * routine to post dr_ap_state change events
 */
picl_errno_t
post_dr_ap_state_change_event(picl_nodehdl_t nodehdl, char *dr_hint,
    uint8_t wait)
{
    nvlist_t    *nvlp;  /* nvlist of event specific args */
    size_t      nvl_size;
    char        *pack_buf = NULL;
    char        dr_ap_id[PICL_PROPNAMELEN_MAX];
    int rc = PICL_SUCCESS;

    if (nodehdl == 0) {
        return (PICL_FAILURE);
    }
    if ((rc = ptree_get_propval_by_name(nodehdl, PICL_PROP_NAME,
        dr_ap_id, sizeof (dr_ap_id))) != PICL_SUCCESS) {
        return (rc);
    }
    if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
        return (PICL_FAILURE);
    }

    if (nvlist_add_string(nvlp, PICLEVENTARG_AP_ID, dr_ap_id) == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    if (nvlist_add_string(nvlp, PICLEVENTARG_HINT, dr_hint) == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    nvlist_free(nvlp);
    rc = post_picl_event(PICLEVENT_DR_AP_STATE_CHANGE, pack_buf,
        nvl_size, nodehdl, wait);
    free(pack_buf);
    return (rc);
}

picl_errno_t
post_cpu_state_change_event(picl_nodehdl_t fruh, char *event_type, uint8_t wait)
{
    nvlist_t    *nvlp;  /* nvlist of event specific args */
    size_t      nvl_size;
    char        *pack_buf = NULL;
    int rc = PICL_SUCCESS;

    if (fruh == 0) {
        return (PICL_FAILURE);
    }

    if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL))
        return (PICL_FAILURE);

    if (nvlist_add_int64(nvlp, PICLEVENTARG_NODEHANDLE, fruh)) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }

    if (nvlist_add_string(nvlp, PICLEVENTARG_CPU_EV_TYPE,
        event_type) == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }

    if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    nvlist_free(nvlp);
    rc = post_picl_event(PICLEVENT_CPU_STATE_CHANGE, pack_buf,
        nvl_size, fruh, wait);
    free(pack_buf);
    return (rc);
}

int
post_sensor_event(picl_nodehdl_t hdl, char *sensor_evalue, uint8_t wait)
{
    nvlist_t    *nvlp;  /* nvlist of event specific args */
    size_t      nvl_size;
    char        *pack_buf = NULL;
    char        dr_ap_id[PICL_PROPNAMELEN_MAX];
    int rc = PICL_SUCCESS;

    if (env_debug & DEBUG)
        syslog(LOG_DEBUG, "Post %s on %llx", sensor_evalue, hdl);
    if (hdl == 0)
        return (PICL_FAILURE);

    if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL))
        return (PICL_FAILURE);

    if (nvlist_add_string(nvlp, PICLEVENTARG_CONDITION,
        sensor_evalue) == -1) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
        nvlist_free(nvlp);
        return (PICL_FAILURE);
    }
    nvlist_free(nvlp);

    if (env_debug & DEBUG) {
        if (ptree_get_propval_by_name(hdl, PICL_PROP_NAME, dr_ap_id,
            sizeof (dr_ap_id)) == PICL_SUCCESS)
            syslog(LOG_DEBUG, "Posting %s on %s", sensor_evalue,
                dr_ap_id);
    }
    rc = post_picl_event(PICLEVENT_CONDITION_CHANGE, pack_buf, nvl_size,
        hdl, wait);
    free(pack_buf);
    return (rc);
}

/*
 * return B_TRUE if admin lock is enabled
 * return B_FALSE if admin lock is disabled
 */
boolean_t
env_admin_lock_enabled(picl_nodehdl_t fruh)
{
    char        adminlock[PICL_PROPNAMELEN_MAX];

    if (ptree_get_propval_by_name(fruh, PICL_PROP_ADMIN_LOCK,
        adminlock, sizeof (adminlock))
        != PICL_SUCCESS) {
        return (B_FALSE);
    }
    if (strcmp(adminlock, PICL_ADMINLOCK_ENABLED) == 0) {
        return (B_TRUE);
    }
    return (B_FALSE);
}