/*
* 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.
* Copyright 2012 Joyent, Inc. All rights reserved.
*/
/*
* /dev/ipmi IPMI monitor
*
* The purpose of this module is to monitor the connection between the system
* and the service processor attached via /dev/ipmi0. The module assumes the SP
* supports the Sun OEM uptime IPMI command. If the BMC connection does not
* exist, or the uptime function is not implemented, then the module unloads
* without doing anything.
*
* When the module is first loaded, or a reset is detected, the module will
* generate the ESC_PLATFORM_SP_RESET sysevent as a system-wide notification to
* indicate that this event has occurred.
*
* Note that this event generation is not guaranteed to have a one-to-one
* correspondence with an SP reset. There is no persistence, so if fmd is
* restarted we will generate this event again. Thus the event only indicates
* the possibility that the SP has been reset. This could be enhanced using fmd
* checkpoints to have some persistent state to avoid this scenario. However,
* it currently serves the useful dual purpose of notifying consumers of system
* startup as well as SP reset through a single channel.
*/
#include <errno.h>
#include <libipmi.h>
#include <libsysevent.h>
#include <string.h>
#include <fm/fmd_api.h>
#include <sys/sysevent/eventdefs.h>
typedef struct sp_monitor {
ipmi_handle_t *sm_hdl;
uint32_t sm_seconds;
uint32_t sm_generation;
hrtime_t sm_interval;
} sp_monitor_t;
static void
sp_post_sysevent(fmd_hdl_t *hdl)
{
sp_monitor_t *smp = fmd_hdl_getspecific(hdl);
sysevent_id_t eid;
fmd_hdl_debug(hdl, "SP reset detected, posting sysevent");
if (sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET,
SUNW_VENDOR, "fmd", NULL, &eid) != 0) {
fmd_hdl_debug(hdl, "failed to send sysevent: %s",
strerror(errno));
/*
* We reset the seconds and generation so that the next time
* through we will try to post the sysevent again.
*/
smp->sm_seconds = -1U;
smp->sm_generation = -1U;
}
}
/*ARGSUSED*/
static void
sp_timeout(fmd_hdl_t *hdl, id_t id, void *data)
{
sp_monitor_t *smp = fmd_hdl_getspecific(hdl);
uint32_t seconds, generation;
if (ipmi_sunoem_uptime(smp->sm_hdl, &seconds, &generation) != 0) {
/*
* Ignore uptime failures. We will generate the appropriate
* event when it comes back online.
*/
fmd_hdl_debug(hdl, "failed to get uptime: %s",
ipmi_errmsg(smp->sm_hdl));
} else {
/*
* We want to catch cases where the generation number is
* explicitly reset, or when the SP configuration is reset after
* a reboot (and the generation number is 0). We also post a
* sysevent when the module initially loads, since we can't be
* sure if we missed a SP reset or not.
*/
if (seconds < smp->sm_seconds ||
generation != smp->sm_generation ||
smp->sm_seconds == 0)
sp_post_sysevent(hdl);
smp->sm_seconds = seconds;
smp->sm_generation = generation;
}
(void) fmd_timer_install(hdl, NULL, NULL, smp->sm_interval);
}
static const fmd_hdl_ops_t fmd_ops = {
NULL, /* fmdo_recv */
sp_timeout, /* fmdo_timeout */
NULL, /* fmdo_close */
NULL, /* fmdo_stats */
NULL, /* fmdo_gc */
};
static const fmd_prop_t fmd_props[] = {
{ "interval", FMD_TYPE_TIME, "60sec" },
{ NULL, 0, NULL }
};
static const fmd_hdl_info_t fmd_info = {
"Service Processor Monitor", "1.0", &fmd_ops, fmd_props
};
void
_fmd_init(fmd_hdl_t *hdl)
{
sp_monitor_t *smp;
int error;
char *msg;
if (fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info) != 0)
return;
smp = fmd_hdl_zalloc(hdl, sizeof (sp_monitor_t), FMD_SLEEP);
fmd_hdl_setspecific(hdl, smp);
if ((smp->sm_hdl = ipmi_open(&error, &msg, IPMI_TRANSPORT_BMC, NULL))
== NULL) {
/*
* If /dev/ipmi0 doesn't exist on the system, then unload the
* module without doing anything.
*/
if (error != EIPMI_BMC_OPEN_FAILED)
fmd_hdl_abort(hdl, "failed to initialize IPMI "
"connection: %s\n", msg);
fmd_hdl_debug(hdl, "failed to load: no IPMI connection "
"present");
fmd_hdl_free(hdl, smp, sizeof (sp_monitor_t));
fmd_hdl_unregister(hdl);
return;
}
/*
* Attempt an initial uptime() call. If the IPMI command is
* unrecognized, then this is an unsupported platform and the module
* should be unloaded. Any other error is treated is transient failure.
*/
if ((error = ipmi_sunoem_uptime(smp->sm_hdl, &smp->sm_seconds,
&smp->sm_generation)) != 0 &&
ipmi_errno(smp->sm_hdl) == EIPMI_INVALID_COMMAND) {
fmd_hdl_debug(hdl, "failed to load: uptime command "
"not supported");
ipmi_close(smp->sm_hdl);
fmd_hdl_free(hdl, smp, sizeof (sp_monitor_t));
fmd_hdl_unregister(hdl);
return;
}
smp->sm_interval = fmd_prop_get_int64(hdl, "interval");
if (error == 0)
fmd_hdl_debug(hdl, "successfully loaded, uptime = %u seconds "
"(generation %u)", smp->sm_seconds, smp->sm_generation);
else
fmd_hdl_debug(hdl, "successfully loaded, but uptime call "
"failed: %s", ipmi_errmsg(smp->sm_hdl));
/*
* Setup the recurring timer.
*/
(void) fmd_timer_install(hdl, NULL, NULL, 0);
}
void
_fmd_fini(fmd_hdl_t *hdl)
{
sp_monitor_t *smp = fmd_hdl_getspecific(hdl);
if (smp) {
ipmi_close(smp->sm_hdl);
fmd_hdl_free(hdl, smp, sizeof (sp_monitor_t));
}
}