/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * SMF software-diagnosis subsidiary
 *
 * We model service instances in maintenance state as a defect diagnosis
 * in FMA.  When an instance transitions to maintenance state the SMF
 * graph engine publishes an event which we subscribe to here, and diagnose
 * a corresponding defect.
 *
 * We always solve a case immediately after opening it.  But we leave the
 * case close action to the response agent which needs to cache case UUIDs.
 * So in the normal case, where software-response is loaded and operational,
 * our cases will transition to CLOSED state moments after we solve them.
 * But if fmd restarts in the interim or if software-response is not loaded
 * then our cases may hang around in SOLVED state for a while, which means
 * we could iterate over them on receipt of new events.  But we don't -
 * we blindly solve a new case for every new maintenance event received,
 * and leave it to the fmd duplicate detection and history-based diagnosis
 * logic to do the right thing.
 *
 * Our sibling SMF response subsidiary propogates fmadm-initiated repairs
 * into SMF, and svcadm-initiated clears back into FMA.  In both cases
 * the case is moved on to the RESOLVED state, even if fmd is unable to
 * verify that the service is out of maintenance state (i.e., no longer
 * isolated).  If the service immediately re-enters maintenance state then
 * we diagnose a fresh case.  The history-based diagnosis changes in fmd
 * "do the right thing" and avoid throwing away new cases as duplicates
 * of old ones hanging around in the "resolved but not all usable again"
 * state.
 */

#include <strings.h>
#include <fm/libtopo.h>
#include <fm/fmd_fmri.h>

#include "../../common/sw.h"
#include "smf.h"

static id_t myid;

static struct {
	fmd_stat_t swde_smf_diagnosed;
	fmd_stat_t swde_smf_bad_class;
	fmd_stat_t swde_smf_no_attr;
	fmd_stat_t swde_smf_bad_attr;
	fmd_stat_t swde_smf_bad_fmri;
	fmd_stat_t swde_smf_no_uuid;
	fmd_stat_t swde_smf_no_reason_short;
	fmd_stat_t swde_smf_no_reason_long;
	fmd_stat_t swde_smf_no_svcname;
	fmd_stat_t swde_smf_admin_maint_drop;
	fmd_stat_t swde_smf_bad_nvlist_pack;
	fmd_stat_t swde_smf_dupuuid;
} swde_smf_stats = {
	{ "swde_smf_diagnosed", FMD_TYPE_UINT64,
	    "maintenance state defects published" },
	{ "swde_smf_bad_class", FMD_TYPE_UINT64,
	    "incorrect event class received" },
	{ "swde_smf_no_attr", FMD_TYPE_UINT64,
	    "malformed event - missing attr nvlist" },
	{ "swde_smf_bad_attr", FMD_TYPE_UINT64,
	    "malformed event - invalid attr list" },
	{ "swde_smf_bad_fmri", FMD_TYPE_UINT64,
	    "malformed event - fmri2str fails" },
	{ "swde_smf_no_uuid", FMD_TYPE_UINT64,
	    "malformed event - missing uuid" },
	{ "swde_smf_no_reason_short", FMD_TYPE_UINT64,
	    "SMF transition event had no reason-short" },
	{ "swde_smf_no_reason_long", FMD_TYPE_UINT64,
	    "SMF transition event had no reason-long" },
	{ "swde_smf_no_svcname", FMD_TYPE_UINT64,
	    "SMF transition event had no svc-string" },
	{ "swde_smf_admin_maint_drop", FMD_TYPE_UINT64,
	    "maintenance transitions requested by admin - no diagnosis" },
	{ "swde_smf_bad_nvlist_pack", FMD_TYPE_UINT64,
	    "failed nvlist_size or nvlist_pack" },
	{ "swde_smf_dupuuid", FMD_TYPE_UINT64,
	    "duplicate events received" },
};

#define	SWDE_SMF_CASEDATA_VERS		1

typedef struct swde_smf_casedata {
	uint32_t scd_vers;		/* must be first member */
	size_t scd_nvlbufsz;		/* size of following buffer */
					/* packed fmri nvlist follows */
} swde_smf_casedata_t;

#define	BUMPSTAT(stat)		swde_smf_stats.stat.fmds_value.ui64++

/*ARGSUSED*/
void
swde_smf_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl,
    const char *class, void *arg)
{
	char *rsn = NULL, *rsnl = NULL, *svcname = NULL;
	nvlist_t *attr, *svcfmri, *defect;
	swde_smf_casedata_t *cdp;
	fmd_case_t *cp;
	char *fmribuf;
	char *uuid;
	size_t sz;

	if (!fmd_nvl_class_match(hdl, nvl, TRANCLASS("maintenance"))) {
		BUMPSTAT(swde_smf_bad_class);
		return;
	}

	if (nvlist_lookup_nvlist(nvl, FM_IREPORT_ATTRIBUTES, &attr) != 0) {
		BUMPSTAT(swde_smf_no_attr);
		return;
	}

	if (nvlist_lookup_string(nvl, FM_IREPORT_UUID, &uuid) != 0) {
		BUMPSTAT(swde_smf_no_uuid);
		return;
	}

	if (nvlist_lookup_nvlist(attr, "svc", &svcfmri) != 0) {
		BUMPSTAT(swde_smf_bad_attr);
		return;
	}

	if (nvlist_lookup_string(attr, "reason-short", &rsn) != 0) {
		BUMPSTAT(swde_smf_no_reason_short);
		return;
	}

	if (nvlist_lookup_string(attr, "reason-long", &rsnl) != 0) {
		BUMPSTAT(swde_smf_no_reason_long);
		return;
	}

	if (nvlist_lookup_string(attr, "svc-string", &svcname) != 0) {
		BUMPSTAT(swde_smf_no_svcname);
		return;
	}

	if (strcmp(rsn, "administrative_request") == 0) {
		BUMPSTAT(swde_smf_admin_maint_drop);
		return;
	}

	/*
	 * Our case checkpoint data, version 1.
	 */
	if (nvlist_size(svcfmri, &sz, NV_ENCODE_NATIVE) != 0) {
		BUMPSTAT(swde_smf_bad_nvlist_pack);
		return;
	}
	cdp = fmd_hdl_zalloc(hdl, sizeof (*cdp) + sz, FMD_SLEEP);
	cdp->scd_vers = SWDE_SMF_CASEDATA_VERS;
	fmribuf = (char *)cdp + sizeof (*cdp);
	cdp->scd_nvlbufsz = sz;
	(void) nvlist_pack(svcfmri, &fmribuf, &sz, NV_ENCODE_NATIVE, 0);

	/*
	 * Open a case with UUID matching the originating event, and no
	 * associated serialization data.  Create a defect and add it to
	 * the case, and link the originating event to the case.  This
	 * call will return NULL if a case with the requested UUID already
	 * exists, which would mean we are processing an event twice so
	 * we can discard.
	 */
	if ((cp = swde_case_open(hdl, myid, uuid, SWDE_SMF_CASEDATA_VERS,
	    (void *)cdp, sizeof (*cdp) + sz)) == NULL) {
		BUMPSTAT(swde_smf_dupuuid);
		fmd_hdl_free(hdl, cdp, sizeof (*cdp) + sz);
		return;
	}

	defect = fmd_nvl_create_defect(hdl, SW_SMF_MAINT_DEFECT,
	    100, svcfmri, NULL, svcfmri);
	if (rsn != NULL)
		(void) nvlist_add_string(defect, "reason-short", rsn);
	if (rsnl != NULL)
		(void) nvlist_add_string(defect, "reason-long", rsnl);
	if (svcname != NULL)
		(void) nvlist_add_string(defect, "svc-string", svcname);
	fmd_case_add_suspect(hdl, cp, defect);
	fmd_case_add_ereport(hdl, cp, ep);

	/*
	 * Now solve the case, and immediately close it.  Although the
	 * resource is already isolated (SMF put it in maintenance state)
	 * we do not immediately close the case here - our sibling response
	 * logic will do that after caching the case UUID.
	 */
	fmd_case_solve(hdl, cp);
	BUMPSTAT(swde_smf_diagnosed);
}

/*
 * In the normal course of events we keep in sync with SMF through the
 * maintenance enter/clear events it raises.  Even if a maintenance
 * state is cleared using svcadm while fmd is not running, the event
 * will pend and be consumed when fmd does start and we'll close the
 * case (in the response agent).
 *
 * But is is possible for discontinuities to produce some confusion:
 *
 *	- if an instance is in maintenance state (and so shown in svcs -x
 *	  and fmadm faulty output) at the time we clone a new boot
 *	  environment then when we boot the new BE we can be out of
 *	  sync if the instance is cleared when we boot there
 *
 *	- meddling with /var/fm state - eg manual clear of files there,
 *	  or restore of old state
 *
 * So as an extra guard we have a case verify function which is called
 * at fmd restart (module load for software-diagnosis).  We must
 * return 0 to close the case, non-zero to retain it.
 */
int
swde_smf_vrfy(fmd_hdl_t *hdl, fmd_case_t *cp)
{
	swde_smf_casedata_t *cdp;
	nvlist_t *svcfmri;
	uint32_t v;
	int rv;

	cdp = swde_case_data(hdl, cp, &v);

	if (cdp == NULL || v != 1)
		return (0);	/* bad or damaged - just close */

	if (nvlist_unpack((char *)cdp + sizeof (*cdp),
	    cdp->scd_nvlbufsz, &svcfmri, 0) != 0)
		return (0);	/* ditto */

	switch (fmd_nvl_fmri_service_state(hdl, svcfmri)) {
	case FMD_SERVICE_STATE_UNUSABLE:
		/*
		 * Keep case iff in maintenance state
		 */
		rv = 1;
		break;

	default:
		/*
		 * Discard the case for all other states - cleared,
		 * service no longer exists, ... whatever.
		 */
		rv = 0;
		break;
	}

	nvlist_free(svcfmri);
	return (rv);
}

const struct sw_disp swde_smf_disp[] = {
	{ TRANCLASS("maintenance"), swde_smf_recv, NULL },
	{ NULL, NULL, NULL }
};

/*ARGSUSED*/
int
swde_smf_init(fmd_hdl_t *hdl, id_t id, const struct sw_disp **dpp, int *nelemp)
{
	myid = id;

	(void) fmd_stat_create(hdl, FMD_STAT_NOALLOC, sizeof (swde_smf_stats) /
	    sizeof (fmd_stat_t), (fmd_stat_t *)&swde_smf_stats);

	fmd_hdl_subscribe(hdl, TRANCLASS("maintenance"));

	*dpp = &swde_smf_disp[0];
	*nelemp = sizeof (swde_smf_disp) / sizeof (swde_smf_disp[0]);
	return (SW_SUB_INIT_SUCCESS);
}

const struct sw_subinfo smf_diag_info = {
	"smf diagnosis",		/* swsub_name */
	SW_CASE_SMF,			/* swsub_casetype */
	swde_smf_init,			/* swsub_init */
	NULL,				/* swsub_fini */
	NULL,				/* swsub_timeout */
	NULL,				/* swsub_case_close */
	swde_smf_vrfy,			/* swsub_case_vrfy */
};