1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27#pragma ident	"%Z%%M%	%I%	%E% SMI"
28
29#include <sys/fm/protocol.h>
30#include <limits.h>
31
32#include <fmd_alloc.h>
33#include <fmd_subr.h>
34#include <fmd_event.h>
35#include <fmd_string.h>
36#include <fmd_module.h>
37#include <fmd_case.h>
38#include <fmd_log.h>
39#include <fmd_time.h>
40#include <fmd_topo.h>
41#include <fmd_ctl.h>
42
43#include <fmd.h>
44
45static void
46fmd_event_nvwrap(fmd_event_impl_t *ep)
47{
48	(void) nvlist_remove_all(ep->ev_nvl, FMD_EVN_TTL);
49	(void) nvlist_remove_all(ep->ev_nvl, FMD_EVN_TOD);
50
51	(void) nvlist_add_uint8(ep->ev_nvl,
52	    FMD_EVN_TTL, ep->ev_ttl);
53	(void) nvlist_add_uint64_array(ep->ev_nvl,
54	    FMD_EVN_TOD, (uint64_t *)&ep->ev_time, 2);
55}
56
57static void
58fmd_event_nvunwrap(fmd_event_impl_t *ep, const fmd_timeval_t *tp)
59{
60	uint64_t *tod;
61	uint_t n;
62
63	if (nvlist_lookup_uint8(ep->ev_nvl, FMD_EVN_TTL, &ep->ev_ttl) != 0) {
64		ep->ev_flags |= FMD_EVF_LOCAL;
65		ep->ev_ttl = (uint8_t)fmd.d_xprt_ttl;
66	}
67
68	if (tp != NULL)
69		ep->ev_time = *tp;
70	else if (nvlist_lookup_uint64_array(ep->ev_nvl,
71	    FMD_EVN_TOD, &tod, &n) == 0 && n >= 2)
72		ep->ev_time = *(const fmd_timeval_t *)tod;
73	else
74		fmd_time_sync(&ep->ev_time, &ep->ev_hrt, 1);
75}
76
77fmd_event_t *
78fmd_event_recreate(uint_t type, const fmd_timeval_t *tp,
79    nvlist_t *nvl, void *data, fmd_log_t *lp, off64_t off, size_t len)
80{
81	fmd_event_impl_t *ep = fmd_alloc(sizeof (fmd_event_impl_t), FMD_SLEEP);
82
83	fmd_timeval_t tod;
84	hrtime_t hr0;
85
86	(void) pthread_mutex_init(&ep->ev_lock, NULL);
87	ep->ev_refs = 0;
88	ASSERT(type < FMD_EVT_NTYPES);
89	ep->ev_type = (uint8_t)type;
90	ep->ev_state = FMD_EVS_RECEIVED;
91	ep->ev_flags = FMD_EVF_REPLAY;
92	ep->ev_nvl = nvl;
93	ep->ev_data = data;
94	ep->ev_log = lp;
95	ep->ev_off = off;
96	ep->ev_len = len;
97
98	fmd_event_nvunwrap(ep, tp);
99
100	/*
101	 * If we're not restoring from a log, the event is marked volatile.  If
102	 * we are restoring from a log, then hold the log pointer and increment
103	 * the pending count.  If we're using a log but no offset and data len
104	 * are specified, it's a checkpoint event: don't replay or set pending.
105	 */
106	if (lp == NULL)
107		ep->ev_flags |= FMD_EVF_VOLATILE;
108	else if (off != 0 && len != 0)
109		fmd_log_hold_pending(lp);
110	else {
111		ep->ev_flags &= ~FMD_EVF_REPLAY;
112		fmd_log_hold(lp);
113	}
114
115	/*
116	 * Sample a (TOD, hrtime) pair from the current system clocks and then
117	 * compute ev_hrt by taking the delta between this TOD and ev_time.
118	 */
119	fmd_time_sync(&tod, &hr0, 1);
120	fmd_time_tod2hrt(hr0, &tod, &ep->ev_time, &ep->ev_hrt);
121
122	fmd_event_nvwrap(ep);
123	return ((fmd_event_t *)ep);
124}
125
126fmd_event_t *
127fmd_event_create(uint_t type, hrtime_t hrt, nvlist_t *nvl, void *data)
128{
129	fmd_event_impl_t *ep = fmd_alloc(sizeof (fmd_event_impl_t), FMD_SLEEP);
130
131	fmd_timeval_t tod;
132	hrtime_t hr0;
133	const char *p;
134	uint64_t ena;
135
136	(void) pthread_mutex_init(&ep->ev_lock, NULL);
137	ep->ev_refs = 0;
138	ASSERT(type < FMD_EVT_NTYPES);
139	ep->ev_type = (uint8_t)type;
140	ep->ev_state = FMD_EVS_RECEIVED;
141	ep->ev_flags = FMD_EVF_VOLATILE | FMD_EVF_REPLAY | FMD_EVF_LOCAL;
142	ep->ev_ttl = (uint8_t)fmd.d_xprt_ttl;
143	ep->ev_nvl = nvl;
144	ep->ev_data = data;
145	ep->ev_log = NULL;
146	ep->ev_off = 0;
147	ep->ev_len = 0;
148
149	/*
150	 * Sample TOD and then set ev_time to the earlier TOD corresponding to
151	 * the input hrtime value.  This needs to be improved later: hrestime
152	 * should be sampled by the transport and passed as an input parameter.
153	 */
154	fmd_time_sync(&tod, &hr0, 1);
155
156	if (hrt == FMD_HRT_NOW)
157		hrt = hr0; /* use hrtime sampled by fmd_time_sync() */
158
159	/*
160	 * If this is an FMA protocol event of class "ereport.*" that contains
161	 * valid ENA, we can compute a more precise bound on the event time.
162	 */
163	if (type == FMD_EVT_PROTOCOL && (p = strchr(data, '.')) != NULL &&
164	    strncmp(data, FM_EREPORT_CLASS, (size_t)(p - (char *)data)) == 0 &&
165	    nvlist_lookup_uint64(nvl, FM_EREPORT_ENA, &ena) == 0 &&
166	    fmd.d_clockops == &fmd_timeops_native)
167		hrt = fmd_time_ena2hrt(hrt, ena);
168
169	fmd_time_hrt2tod(hr0, &tod, hrt, &ep->ev_time);
170	ep->ev_hrt = hrt;
171
172	fmd_event_nvwrap(ep);
173	return ((fmd_event_t *)ep);
174}
175
176void
177fmd_event_destroy(fmd_event_t *e)
178{
179	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
180
181	ASSERT(MUTEX_HELD(&ep->ev_lock));
182	ASSERT(ep->ev_refs == 0);
183
184	/*
185	 * If the current state is RECEIVED (i.e. no module has accepted the
186	 * event) and the event was logged, then change the state to DISCARDED.
187	 */
188	if (ep->ev_state == FMD_EVS_RECEIVED)
189		ep->ev_state = FMD_EVS_DISCARDED;
190
191	/*
192	 * If the current state is DISCARDED, ACCEPTED, or DIAGNOSED and the
193	 * event has not yet been commited, then attempt to commit it now.
194	 */
195	if (ep->ev_state != FMD_EVS_RECEIVED && (ep->ev_flags & (
196	    FMD_EVF_VOLATILE | FMD_EVF_REPLAY)) == FMD_EVF_REPLAY)
197		fmd_log_commit(ep->ev_log, e);
198
199	if (ep->ev_log != NULL) {
200		if (ep->ev_flags & FMD_EVF_REPLAY)
201			fmd_log_decommit(ep->ev_log, e);
202		fmd_log_rele(ep->ev_log);
203	}
204
205	/*
206	 * Perform any event type-specific cleanup activities, and then free
207	 * the name-value pair list and underlying event data structure.
208	 */
209	switch (ep->ev_type) {
210	case FMD_EVT_TIMEOUT:
211		fmd_free(ep->ev_data, sizeof (fmd_modtimer_t));
212		break;
213	case FMD_EVT_CLOSE:
214	case FMD_EVT_PUBLISH:
215		fmd_case_rele(ep->ev_data);
216		break;
217	case FMD_EVT_CTL:
218		fmd_ctl_fini(ep->ev_data);
219		break;
220	case FMD_EVT_TOPO:
221		fmd_topo_rele(ep->ev_data);
222		break;
223	}
224
225	if (ep->ev_nvl != NULL)
226		nvlist_free(ep->ev_nvl);
227
228	fmd_free(ep, sizeof (fmd_event_impl_t));
229}
230
231void
232fmd_event_hold(fmd_event_t *e)
233{
234	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
235
236	(void) pthread_mutex_lock(&ep->ev_lock);
237	ep->ev_refs++;
238	ASSERT(ep->ev_refs != 0);
239	(void) pthread_mutex_unlock(&ep->ev_lock);
240
241	if (ep->ev_type == FMD_EVT_CTL)
242		fmd_ctl_hold(ep->ev_data);
243}
244
245void
246fmd_event_rele(fmd_event_t *e)
247{
248	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
249
250	if (ep->ev_type == FMD_EVT_CTL)
251		fmd_ctl_rele(ep->ev_data);
252
253	(void) pthread_mutex_lock(&ep->ev_lock);
254	ASSERT(ep->ev_refs != 0);
255
256	if (--ep->ev_refs == 0)
257		fmd_event_destroy(e);
258	else
259		(void) pthread_mutex_unlock(&ep->ev_lock);
260}
261
262/*
263 * Transition event from its current state to the specified state.  The states
264 * for events are defined in fmd_event.h and work according to the diagram:
265 *
266 *  -------------     -------------     State      Description
267 * ( RECEIVED =1 )-->( ACCEPTED =2 )    ---------- ---------------------------
268 *  -----+-------\    ------+------     DISCARDED  No active references in fmd
269 *       |        \         |           RECEIVED   Active refs in fmd, no case
270 *  -----v-------  \  ------v------     ACCEPTED   Active refs, case assigned
271 * ( DISCARDED=0 )  v( DIAGNOSED=3 )    DIAGNOSED  Active refs, case solved
272 *  -------------     -------------
273 *
274 * Since events are reference counted on behalf of multiple subscribers, any
275 * attempt to transition an event to an "earlier" or "equal" state (as defined
276 * by the numeric state values shown in the diagram) is silently ignored.
277 * An event begins life in the RECEIVED state, so the RECEIVED -> DISCARDED
278 * transition is handled by fmd_event_destroy() when no references remain.
279 */
280void
281fmd_event_transition(fmd_event_t *e, uint_t state)
282{
283	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
284
285	(void) pthread_mutex_lock(&ep->ev_lock);
286
287	TRACE((FMD_DBG_EVT, "event %p transition %u -> %u",
288	    (void *)ep, ep->ev_state, state));
289
290	if (state <= ep->ev_state) {
291		(void) pthread_mutex_unlock(&ep->ev_lock);
292		return; /* no state change necessary */
293	}
294
295	if (ep->ev_state < FMD_EVS_RECEIVED || ep->ev_state > FMD_EVS_DIAGNOSED)
296		fmd_panic("illegal transition %u -> %u\n", ep->ev_state, state);
297
298	ep->ev_state = state;
299	(void) pthread_mutex_unlock(&ep->ev_lock);
300}
301
302/*
303 * If the specified event is DISCARDED, ACCEPTED, OR DIAGNOSED and it has been
304 * written to a log but is still marked for replay, attempt to commit it to the
305 * log so that it will not be replayed.  If fmd_log_commit() is successful, it
306 * will clear the FMD_EVF_REPLAY flag on the event for us.
307 */
308void
309fmd_event_commit(fmd_event_t *e)
310{
311	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
312
313	(void) pthread_mutex_lock(&ep->ev_lock);
314
315	if (ep->ev_state != FMD_EVS_RECEIVED && (ep->ev_flags & (
316	    FMD_EVF_VOLATILE | FMD_EVF_REPLAY)) == FMD_EVF_REPLAY)
317		fmd_log_commit(ep->ev_log, e);
318
319	(void) pthread_mutex_unlock(&ep->ev_lock);
320}
321
322/*
323 * Compute the delta between events in nanoseconds.  To account for very old
324 * events which are replayed, we must handle the case where ev_hrt is negative.
325 * We convert the hrtime_t's to unsigned 64-bit integers and then handle the
326 * case where 'old' is greater than 'new' (i.e. high-res time has wrapped).
327 */
328hrtime_t
329fmd_event_delta(fmd_event_t *e1, fmd_event_t *e2)
330{
331	uint64_t old = ((fmd_event_impl_t *)e1)->ev_hrt;
332	uint64_t new = ((fmd_event_impl_t *)e2)->ev_hrt;
333
334	return (new >= old ? new - old : (UINT64_MAX - old) + new + 1);
335}
336
337hrtime_t
338fmd_event_hrtime(fmd_event_t *ep)
339{
340	return (((fmd_event_impl_t *)ep)->ev_hrt);
341}
342
343int
344fmd_event_match(fmd_event_t *e, uint_t type, const void *data)
345{
346	fmd_event_impl_t *ep = (fmd_event_impl_t *)e;
347
348	if (ep->ev_type != type)
349		return (0);
350
351	if (type == FMD_EVT_PROTOCOL)
352		return (fmd_strmatch(ep->ev_data, data));
353	else if (type == FMD_EVT_TIMEOUT)
354		return ((id_t)data == ((fmd_modtimer_t *)ep->ev_data)->mt_id);
355	else
356		return (ep->ev_data == data);
357}
358
359int
360fmd_event_equal(fmd_event_t *e1, fmd_event_t *e2)
361{
362	fmd_event_impl_t *ep1 = (fmd_event_impl_t *)e1;
363	fmd_event_impl_t *ep2 = (fmd_event_impl_t *)e2;
364
365	return (ep1->ev_log != NULL &&
366	    ep1->ev_log == ep2->ev_log && ep1->ev_off == ep2->ev_off);
367}
368