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