common/disk-monitor/dm_platform.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <ctype.h>
#include <libipmi.h>
#include <libnvpair.h>
#include <libuutil.h>
#include <limits.h>
#include <stddef.h>
#include <string.h>

#include "diskmon_conf.h"
#include "dm_platform.h"
#include "util.h"

/* For the purposes of disk capacity, a <X>B is 1000x, not 1024x */
#define ONE_KILOBYTE 1000.0
#define ONE_MEGABYTE (ONE_KILOBYTE * 1000)
#define ONE_GIGABYTE (ONE_MEGABYTE * 1000)
#define ONE_TERABYTE (ONE_GIGABYTE * 1000)
#define ONE_PETABYTE (ONE_TERABYTE * 1000)

static ipmi_handle_t *g_ipmi_hdl;

typedef enum {
    IPMI_CACHE_SENSOR,
    IPMI_CACHE_FRU
} ipmi_cache_type_t;

typedef struct ipmi_cache_entry {
    ipmi_cache_type_t           ic_type;
    uu_list_node_t              ic_node;
    union {
        ipmi_set_sensor_reading_t   ic_sensor;
        ipmi_sunoem_fru_t       ic_fru;
    } ic_data;
} ipmi_cache_entry_t;

static pthread_mutex_t g_ipmi_mtx = PTHREAD_MUTEX_INITIALIZER;
static uu_list_pool_t *g_ipmi_cache_pool;
static uu_list_t *g_ipmi_cache;

/*
 * The textual strings that are used in the actions may be one of the
 * following forms:
 *
 * [1] `fru gid=<n> hdd=<m>'
 * [2] `sensor id=<x> assert=<y> deassert=<z>'
 *
 * The generic parser will take a string and spit out the first token
 * (e.g. `fru' or `sensor') and an nvlist that contains the key-value
 * pairs in the rest of the string.  The assumption is that there are
 * no embedded spaces or tabs in the keys or values.
 */

static boolean_t
isnumber(const char *str)
{
    boolean_t hex = B_FALSE;
    int digits = 0;

    if (strncasecmp(str, "0x", 2) == 0) {
        hex = B_TRUE;
        str += 2;
    } else if (*str == '-' || *str == '+') {
        str++;
    }

    while (*str != 0) {
        if ((hex && !isxdigit(*str)) ||
            (!hex && !isdigit(*str))) {
            return (B_FALSE);
        }

        str++;
        digits++;
    }

    return ((digits == 0) ? B_FALSE : B_TRUE);
}

static void
tolowerString(char *str)
{
    while (*str != 0) {
        *str = tolower(*str);
        str++;
    }
}

static boolean_t
parse_action_string(const char *actionString, char **cmdp, nvlist_t **propsp)
{
    char *action;
    char *tok, *lasts, *eq;
    int actionlen;
    boolean_t rv = B_TRUE;

    if (nvlist_alloc(propsp, NV_UNIQUE_NAME, 0) != 0)
        return (B_FALSE);

    actionlen = strlen(actionString) + 1;
    action = dstrdup(actionString);

    *cmdp = NULL;

    if ((tok = strtok_r(action, " \t", &lasts)) != NULL) {

        *cmdp = dstrdup(tok);

        while (rv && (tok = strtok_r(NULL, " \t", &lasts)) != NULL) {

            /* Look for a name=val construct */
            if ((eq = strchr(tok, '=')) != NULL && eq[1] != 0) {

                *eq = 0;
                eq++;

                /*
                 * Convert token to lowercase to preserve
                 * case-insensitivity, because nvlist doesn't
                 * do case-insensitive lookups
                 */
                tolowerString(tok);

                if (isnumber(eq)) {
                    /* Integer property */

                    if (nvlist_add_uint64(*propsp, tok,
                        strtoull(eq, NULL, 0)) != 0)
                        rv = B_FALSE;
                } else {
                    /* String property */

                    if (nvlist_add_string(*propsp, tok,
                        eq) != 0)
                        rv = B_FALSE;
                }
            } else if (eq == NULL) {
                /* Boolean property */
                if (nvlist_add_boolean(*propsp, tok) != 0)
                    rv = B_FALSE;
            } else /* Parse error (`X=' is invalid) */
                rv = B_FALSE;
        }
    } else
        rv = B_FALSE;

    dfree(action, actionlen);
    if (!rv) {
        if (*cmdp) {
            dstrfree(*cmdp);
            *cmdp = NULL;
        }
        nvlist_free(*propsp);
        *propsp = NULL;
    }
    return (rv);
}

static int
platform_update_fru(nvlist_t *props, dm_fru_t *frup)
{
    uint64_t gid, hdd;
    ipmi_sunoem_fru_t fru;
    char *buf;
    ipmi_cache_entry_t *entry;

    if (nvlist_lookup_uint64(props, "gid", &gid) != 0 ||
        nvlist_lookup_uint64(props, "hdd", &hdd) != 0) {
        return (-1);
    }

    fru.isf_type = (uint8_t)gid;
    fru.isf_id = (uint8_t)hdd;

    buf = (char *)dzmalloc(sizeof (fru.isf_data.disk.isf_capacity) + 1);

    (void) memcpy(fru.isf_data.disk.isf_manufacturer, frup->manuf,
        MIN(sizeof (fru.isf_data.disk.isf_manufacturer),
        sizeof (frup->manuf)));
    (void) memcpy(fru.isf_data.disk.isf_model, frup->model,
        MIN(sizeof (fru.isf_data.disk.isf_model), sizeof (frup->model)));
    (void) memcpy(fru.isf_data.disk.isf_serial, frup->serial,
        MIN(sizeof (fru.isf_data.disk.isf_serial), sizeof (frup->serial)));
    (void) memcpy(fru.isf_data.disk.isf_version, frup->rev,
        MIN(sizeof (fru.isf_data.disk.isf_version), sizeof (frup->rev)));
    /*
     * Print the size of the disk to a temporary buffer whose size is
     * 1 more than the size of the buffer in the ipmi request data
     * structure, so we can get the full 8 characters (instead of 7 + NUL)
     */
    (void) snprintf(buf, sizeof (fru.isf_data.disk.isf_capacity) + 1,
        "%.1f%s",
        frup->size_in_bytes >= ONE_PETABYTE ?
        (frup->size_in_bytes / ONE_PETABYTE) :
        (frup->size_in_bytes >= ONE_TERABYTE ?
        (frup->size_in_bytes / ONE_TERABYTE) :
        (frup->size_in_bytes >= ONE_GIGABYTE ?
        (frup->size_in_bytes / ONE_GIGABYTE) :
        (frup->size_in_bytes >= ONE_MEGABYTE ?
        (frup->size_in_bytes / ONE_MEGABYTE) :
        (frup->size_in_bytes / ONE_KILOBYTE)))),

        frup->size_in_bytes >= ONE_PETABYTE ? "PB" :
        (frup->size_in_bytes >= ONE_TERABYTE ? "TB" :
        (frup->size_in_bytes >= ONE_GIGABYTE ? "GB" :
        (frup->size_in_bytes >= ONE_MEGABYTE ? "MB" :
        "KB"))));
    (void) memcpy(fru.isf_data.disk.isf_capacity, buf,
        sizeof (fru.isf_data.disk.isf_capacity));

    dfree(buf, sizeof (fru.isf_data.disk.isf_capacity) + 1);

    if (ipmi_sunoem_update_fru(g_ipmi_hdl, &fru) != 0)
        return (-1);

    /* find a cache entry or create one if necessary */
    for (entry = uu_list_first(g_ipmi_cache); entry != NULL;
        entry = uu_list_next(g_ipmi_cache, entry)) {
        if (entry->ic_type == IPMI_CACHE_FRU &&
            entry->ic_data.ic_fru.isf_type == gid &&
            entry->ic_data.ic_fru.isf_id == hdd)
            break;
    }

    if (entry == NULL) {
        entry = dzmalloc(sizeof (ipmi_cache_entry_t));
        entry->ic_type = IPMI_CACHE_FRU;
        (void) uu_list_insert_before(g_ipmi_cache, NULL, entry);
    }

    (void) memcpy(&entry->ic_data.ic_fru, &fru, sizeof (fru));

    return (0);
}

static int
platform_set_sensor(nvlist_t *props)
{
    uint64_t assertmask = 0, deassertmask = 0, sid;
    boolean_t am_present, dam_present;
    ipmi_set_sensor_reading_t sr, *sp;
    ipmi_cache_entry_t *entry;
    int ret;

    /* We need at least 2 properties: `sid' and (`amask' || `dmask'): */
    am_present = nvlist_lookup_uint64(props, "amask", &assertmask) == 0;
    dam_present = nvlist_lookup_uint64(props, "dmask", &deassertmask) == 0;

    if (nvlist_lookup_uint64(props, "sid", &sid) != 0 ||
        (!am_present && !dam_present)) {
        return (-1);
    }

    if (sid > UINT8_MAX) {
        log_warn("IPMI Plugin: Invalid sensor id `0x%llx'.\n",
            (longlong_t)sid);
        return (-1);
    } else if (assertmask > UINT16_MAX) {
        log_warn("IPMI Plugin: Invalid assertion mask `0x%llx'.\n",
            (longlong_t)assertmask);
        return (-1);
    } else if (assertmask > UINT16_MAX) {
        log_warn("IPMI Plugin: Invalid deassertion mask `0x%llx'.\n",
            (longlong_t)deassertmask);
        return (-1);
    }

    (void) memset(&sr, '\0', sizeof (sr));
    sr.iss_id = (uint8_t)sid;
    if (am_present) {
        sr.iss_assert_op = IPMI_SENSOR_OP_SET;
        sr.iss_assert_state = (uint16_t)assertmask;
    }
    if (dam_present) {
        sr.iss_deassrt_op = IPMI_SENSOR_OP_SET;
        sr.iss_deassert_state = (uint16_t)deassertmask;
    }

    ret = ipmi_set_sensor_reading(g_ipmi_hdl, &sr);

    /* find a cache entry or create one if necessary */
    for (entry = uu_list_first(g_ipmi_cache); entry != NULL;
        entry = uu_list_next(g_ipmi_cache, entry)) {
        if (entry->ic_type == IPMI_CACHE_SENSOR &&
            entry->ic_data.ic_sensor.iss_id == (uint8_t)sid)
            break;
    }

    if (entry == NULL) {
        entry = dzmalloc(sizeof (ipmi_cache_entry_t));
        entry->ic_type = IPMI_CACHE_SENSOR;
        (void) uu_list_insert_before(g_ipmi_cache, NULL, entry);
        entry->ic_data.ic_sensor.iss_id = (uint8_t)sid;
        entry->ic_data.ic_sensor.iss_assert_op = IPMI_SENSOR_OP_SET;
        entry->ic_data.ic_sensor.iss_deassrt_op = IPMI_SENSOR_OP_SET;
    }
    sp = &entry->ic_data.ic_sensor;

    if (am_present) {
        sp->iss_assert_state |= assertmask;
        sp->iss_deassert_state &= ~assertmask;
    }
    if (dam_present) {
        sp->iss_deassert_state |= deassertmask;
        sp->iss_assert_state &= ~deassertmask;
    }

    return (ret);
}

#define PROTOCOL_SEPARATOR ':'

static char *
extract_protocol(const char *action)
{
    char *s = strchr(action, PROTOCOL_SEPARATOR);
    char *proto = NULL;
    int len;
    int i = 0;

    /* The protocol is the string before the separator, but in lower-case */
    if (s) {
        len = (uintptr_t)s - (uintptr_t)action;
        proto = (char *)dmalloc(len + 1);
        while (i < len) {
            proto[i] = tolower(action[i]);
            i++;
        }
        proto[len] = 0;
    }

    return (proto);
}

static char *
extract_action(const char *action)
{
    /* The action is the string after the separator */
    char *s = strchr(action, PROTOCOL_SEPARATOR);

    return (s ? (s + 1) : NULL);
}

static int
do_action(const char *action, dm_fru_t *fru)
{
    nvlist_t    *props;
    char        *cmd;
    int rv = -1;
    char        *protocol = extract_protocol(action);
    char        *actionp = extract_action(action);

    if (strcmp(protocol, "ipmi") != 0) {
        log_err("unknown protocol '%s'\n", protocol);
        dstrfree(protocol);
        return (-1);
    }

    dstrfree(protocol);

    (void) pthread_mutex_lock(&g_ipmi_mtx);
    if (parse_action_string(actionp, &cmd, &props)) {
        if (strcmp(cmd, "fru") == 0) {
            rv = platform_update_fru(props, fru);
        } else if (strcmp(cmd, "state") == 0) {
            rv = platform_set_sensor(props);
        } else {
            log_err("unknown platform action '%s'\n", cmd);
        }
        dstrfree(cmd);
        nvlist_free(props);
    }
    (void) pthread_mutex_unlock(&g_ipmi_mtx);

    return (rv);
}

int
dm_platform_update_fru(const char *action, dm_fru_t *fru)
{
    return (do_action(action, fru));
}

int
dm_platform_indicator_execute(const char *action)
{
    return (do_action(action, NULL));
}

int
dm_platform_resync(void)
{
    ipmi_cache_entry_t *entry;
    int rv = 0;

    (void) pthread_mutex_lock(&g_ipmi_mtx);

    /*
     * Called when the SP is reset, as the sensor/FRU state is not
     * maintained across reboots.  Note that we must update the FRU
     * information first, as certain sensor states prevent this from
     * working.
     */
    for (entry = uu_list_first(g_ipmi_cache); entry != NULL;
        entry = uu_list_next(g_ipmi_cache, entry)) {
        if (entry->ic_type == IPMI_CACHE_FRU)
            rv |= ipmi_sunoem_update_fru(g_ipmi_hdl,
                &entry->ic_data.ic_fru);
    }

    for (entry = uu_list_first(g_ipmi_cache); entry != NULL;
        entry = uu_list_next(g_ipmi_cache, entry)) {
        if (entry->ic_type == IPMI_CACHE_SENSOR)
            rv |= ipmi_set_sensor_reading(g_ipmi_hdl,
                &entry->ic_data.ic_sensor);
    }

    (void) pthread_mutex_unlock(&g_ipmi_mtx);
    return (rv);
}

int
dm_platform_init(void)
{
    int err;
    char *msg;

    if ((g_ipmi_hdl = ipmi_open(&err, &msg, IPMI_TRANSPORT_BMC, NULL))
        == NULL) {
        log_warn("Failed to load libipmi: %s\n", msg);
        return (-1);
    }

    if ((g_ipmi_cache_pool = uu_list_pool_create(
        "ipmi_cache", sizeof (ipmi_cache_entry_t),
        offsetof(ipmi_cache_entry_t, ic_node), NULL, 0)) == NULL)
        return (-1);

    if ((g_ipmi_cache = uu_list_create(g_ipmi_cache_pool, NULL, 0))
        == NULL)
        return (-1);

    return (0);
}

void
dm_platform_fini(void)
{
    if (g_ipmi_hdl)
        ipmi_close(g_ipmi_hdl);
    if (g_ipmi_cache) {
        ipmi_cache_entry_t *entry;

        while ((entry = uu_list_first(g_ipmi_cache)) != NULL) {
            uu_list_remove(g_ipmi_cache, entry);
            dfree(entry, sizeof (*entry));
        }
        uu_list_destroy(g_ipmi_cache);
    }
    if (g_ipmi_cache_pool)
        uu_list_pool_destroy(g_ipmi_cache_pool);
}