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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#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)) == 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);
}