xref: /freebsd/lib/libpmc/pmclog.c (revision 959826ca1bb0a42ddd624bf1803ae2957a3282f3)
1f263522aSJoseph Koshy /*-
25e53a4f9SPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
35e53a4f9SPedro F. Giffuni  *
4c5e73985SJoseph Koshy  * Copyright (c) 2005-2007 Joseph Koshy
5c5e73985SJoseph Koshy  * Copyright (c) 2007 The FreeBSD Foundation
6f263522aSJoseph Koshy  * All rights reserved.
7f263522aSJoseph Koshy  *
8c5e73985SJoseph Koshy  * Portions of this software were developed by A. Joseph Koshy under
9c5e73985SJoseph Koshy  * sponsorship from the FreeBSD Foundation and Google, Inc.
10c5e73985SJoseph Koshy  *
11f263522aSJoseph Koshy  * Redistribution and use in source and binary forms, with or without
12f263522aSJoseph Koshy  * modification, are permitted provided that the following conditions
13f263522aSJoseph Koshy  * are met:
14f263522aSJoseph Koshy  * 1. Redistributions of source code must retain the above copyright
15f263522aSJoseph Koshy  *    notice, this list of conditions and the following disclaimer.
16f263522aSJoseph Koshy  * 2. Redistributions in binary form must reproduce the above copyright
17f263522aSJoseph Koshy  *    notice, this list of conditions and the following disclaimer in the
18f263522aSJoseph Koshy  *    documentation and/or other materials provided with the distribution.
19f263522aSJoseph Koshy  *
20f263522aSJoseph Koshy  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21f263522aSJoseph Koshy  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22f263522aSJoseph Koshy  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23f263522aSJoseph Koshy  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24f263522aSJoseph Koshy  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25f263522aSJoseph Koshy  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26f263522aSJoseph Koshy  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27f263522aSJoseph Koshy  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28f263522aSJoseph Koshy  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29f263522aSJoseph Koshy  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30f263522aSJoseph Koshy  * SUCH DAMAGE.
31f263522aSJoseph Koshy  */
32f263522aSJoseph Koshy 
33f263522aSJoseph Koshy #include <sys/cdefs.h>
34f263522aSJoseph Koshy __FBSDID("$FreeBSD$");
35f263522aSJoseph Koshy 
36f263522aSJoseph Koshy #include <sys/param.h>
37f263522aSJoseph Koshy #include <sys/pmc.h>
38f263522aSJoseph Koshy #include <sys/pmclog.h>
39f263522aSJoseph Koshy 
40f263522aSJoseph Koshy #include <assert.h>
41f263522aSJoseph Koshy #include <errno.h>
42f263522aSJoseph Koshy #include <pmc.h>
43f263522aSJoseph Koshy #include <pmclog.h>
44f263522aSJoseph Koshy #include <stddef.h>
45f263522aSJoseph Koshy #include <stdlib.h>
46f263522aSJoseph Koshy #include <string.h>
47f263522aSJoseph Koshy #include <strings.h>
48f263522aSJoseph Koshy #include <unistd.h>
49*959826caSMatt Macy #include <stdio.h>
50f263522aSJoseph Koshy 
51f263522aSJoseph Koshy #include <machine/pmc_mdep.h>
52f263522aSJoseph Koshy 
530cfab8ddSJoseph Koshy #include "libpmcinternal.h"
540cfab8ddSJoseph Koshy 
55f263522aSJoseph Koshy #define	PMCLOG_BUFFER_SIZE			4096
56f263522aSJoseph Koshy 
57f263522aSJoseph Koshy /*
58f263522aSJoseph Koshy  * API NOTES
59f263522aSJoseph Koshy  *
60f263522aSJoseph Koshy  * The pmclog(3) API is oriented towards parsing an event stream in
61f263522aSJoseph Koshy  * "realtime", i.e., from an data source that may or may not preserve
62f263522aSJoseph Koshy  * record boundaries -- for example when the data source is elsewhere
63f263522aSJoseph Koshy  * on a network.  The API allows data to be fed into the parser zero
64f263522aSJoseph Koshy  * or more bytes at a time.
65f263522aSJoseph Koshy  *
66f263522aSJoseph Koshy  * The state for a log file parser is maintained in a 'struct
67f263522aSJoseph Koshy  * pmclog_parse_state'.  Parser invocations are done by calling
68f263522aSJoseph Koshy  * 'pmclog_read()'; this function will inform the caller when a
69f263522aSJoseph Koshy  * complete event is parsed.
70f263522aSJoseph Koshy  *
71f263522aSJoseph Koshy  * The parser first assembles a complete log file event in an internal
72f263522aSJoseph Koshy  * work area (see "ps_saved" below).  Once a complete log file event
73f263522aSJoseph Koshy  * is read, the parser then parses it and converts it to an event
74f263522aSJoseph Koshy  * descriptor usable by the client.  We could possibly avoid this two
75f263522aSJoseph Koshy  * step process by directly parsing the input log to set fields in the
76f263522aSJoseph Koshy  * event record.  However the parser's state machine would get
77f263522aSJoseph Koshy  * insanely complicated, and this code is unlikely to be used in
78f263522aSJoseph Koshy  * performance critical paths.
79f263522aSJoseph Koshy  */
80f263522aSJoseph Koshy 
81f263522aSJoseph Koshy enum pmclog_parser_state {
82f263522aSJoseph Koshy 	PL_STATE_NEW_RECORD,		/* in-between records */
83f263522aSJoseph Koshy 	PL_STATE_EXPECTING_HEADER,	/* header being read */
84f263522aSJoseph Koshy 	PL_STATE_PARTIAL_RECORD,	/* header present but not the record */
85f263522aSJoseph Koshy 	PL_STATE_ERROR			/* parsing error encountered */
86f263522aSJoseph Koshy };
87f263522aSJoseph Koshy 
88f263522aSJoseph Koshy struct pmclog_parse_state {
89f263522aSJoseph Koshy 	enum pmclog_parser_state ps_state;
90f263522aSJoseph Koshy 	enum pmc_cputype	ps_arch;	/* log file architecture */
91f263522aSJoseph Koshy 	uint32_t		ps_version;	/* hwpmc version */
92f263522aSJoseph Koshy 	int			ps_initialized;	/* whether initialized */
93f263522aSJoseph Koshy 	int			ps_count;	/* count of records processed */
94f263522aSJoseph Koshy 	off_t			ps_offset;	/* stream byte offset */
95f263522aSJoseph Koshy 	union pmclog_entry	ps_saved;	/* saved partial log entry */
96f263522aSJoseph Koshy 	int			ps_svcount;	/* #bytes saved */
97f263522aSJoseph Koshy 	int			ps_fd;		/* active fd or -1 */
98f263522aSJoseph Koshy 	char			*ps_buffer;	/* scratch buffer if fd != -1 */
99f263522aSJoseph Koshy 	char			*ps_data;	/* current parse pointer */
100f263522aSJoseph Koshy 	size_t			ps_len;		/* length of buffered data */
101f263522aSJoseph Koshy };
102f263522aSJoseph Koshy 
103f263522aSJoseph Koshy #define	PMCLOG_HEADER_FROM_SAVED_STATE(PS)				\
104f263522aSJoseph Koshy 	(* ((uint32_t *) &(PS)->ps_saved))
105f263522aSJoseph Koshy 
106f263522aSJoseph Koshy #define	PMCLOG_INITIALIZE_READER(LE,A)	LE = (uint32_t *) &(A)
107f263522aSJoseph Koshy #define	PMCLOG_READ32(LE,V) 		do {				\
108f263522aSJoseph Koshy 		(V)  = *(LE)++;						\
109f263522aSJoseph Koshy 	} while (0)
110f263522aSJoseph Koshy #define	PMCLOG_READ64(LE,V)		do {				\
111f263522aSJoseph Koshy 		uint64_t _v;						\
112f263522aSJoseph Koshy 		_v  = (uint64_t) *(LE)++;				\
113f263522aSJoseph Koshy 		_v |= ((uint64_t) *(LE)++) << 32;			\
114f263522aSJoseph Koshy 		(V) = _v;						\
115f263522aSJoseph Koshy 	} while (0)
116f263522aSJoseph Koshy 
117f263522aSJoseph Koshy #define	PMCLOG_READSTRING(LE,DST,LEN)	strlcpy((DST), (char *) (LE), (LEN))
118f263522aSJoseph Koshy 
119f263522aSJoseph Koshy /*
120f263522aSJoseph Koshy  * Assemble a log record from '*len' octets starting from address '*data'.
121f263522aSJoseph Koshy  * Update 'data' and 'len' to reflect the number of bytes consumed.
122f263522aSJoseph Koshy  *
123f263522aSJoseph Koshy  * '*data' is potentially an unaligned address and '*len' octets may
124f263522aSJoseph Koshy  * not be enough to complete a event record.
125f263522aSJoseph Koshy  */
126f263522aSJoseph Koshy 
127f263522aSJoseph Koshy static enum pmclog_parser_state
128f263522aSJoseph Koshy pmclog_get_record(struct pmclog_parse_state *ps, char **data, ssize_t *len)
129f263522aSJoseph Koshy {
130f263522aSJoseph Koshy 	int avail, copylen, recordsize, used;
131f263522aSJoseph Koshy 	uint32_t h;
132f263522aSJoseph Koshy 	const int HEADERSIZE = sizeof(uint32_t);
133f263522aSJoseph Koshy 	char *src, *dst;
134f263522aSJoseph Koshy 
135f263522aSJoseph Koshy 	if ((avail = *len) <= 0)
136f263522aSJoseph Koshy 		return (ps->ps_state = PL_STATE_ERROR);
137f263522aSJoseph Koshy 
138f263522aSJoseph Koshy 	src = *data;
139f263522aSJoseph Koshy 	h = used = 0;
140f263522aSJoseph Koshy 
141f263522aSJoseph Koshy 	if (ps->ps_state == PL_STATE_NEW_RECORD)
142f263522aSJoseph Koshy 		ps->ps_svcount = 0;
143f263522aSJoseph Koshy 
144f263522aSJoseph Koshy 	dst = (char *) &ps->ps_saved + ps->ps_svcount;
145f263522aSJoseph Koshy 
146f263522aSJoseph Koshy 	switch (ps->ps_state) {
147f263522aSJoseph Koshy 	case PL_STATE_NEW_RECORD:
148f263522aSJoseph Koshy 
149f263522aSJoseph Koshy 		/*
150f263522aSJoseph Koshy 		 * Transitions:
151f263522aSJoseph Koshy 		 *
152f263522aSJoseph Koshy 		 * Case A: avail < headersize
153f263522aSJoseph Koshy 		 *	-> 'expecting header'
154f263522aSJoseph Koshy 		 *
155f263522aSJoseph Koshy 		 * Case B: avail >= headersize
156f263522aSJoseph Koshy 		 *    B.1: avail < recordsize
157f263522aSJoseph Koshy 		 *	   -> 'partial record'
158f263522aSJoseph Koshy 		 *    B.2: avail >= recordsize
159f263522aSJoseph Koshy 		 *         -> 'new record'
160f263522aSJoseph Koshy 		 */
161f263522aSJoseph Koshy 
162f263522aSJoseph Koshy 		copylen = avail < HEADERSIZE ? avail : HEADERSIZE;
163f263522aSJoseph Koshy 		bcopy(src, dst, copylen);
164f263522aSJoseph Koshy 		ps->ps_svcount = used = copylen;
165f263522aSJoseph Koshy 
166f263522aSJoseph Koshy 		if (copylen < HEADERSIZE) {
167f263522aSJoseph Koshy 			ps->ps_state = PL_STATE_EXPECTING_HEADER;
168f263522aSJoseph Koshy 			goto done;
169f263522aSJoseph Koshy 		}
170f263522aSJoseph Koshy 
171f263522aSJoseph Koshy 		src += copylen;
172f263522aSJoseph Koshy 		dst += copylen;
173f263522aSJoseph Koshy 
174f263522aSJoseph Koshy 		h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
175f263522aSJoseph Koshy 		recordsize = PMCLOG_HEADER_TO_LENGTH(h);
176f263522aSJoseph Koshy 
177f263522aSJoseph Koshy 		if (recordsize <= 0)
178f263522aSJoseph Koshy 			goto error;
179f263522aSJoseph Koshy 
180f263522aSJoseph Koshy 		if (recordsize <= avail) { /* full record available */
181f263522aSJoseph Koshy 			bcopy(src, dst, recordsize - copylen);
182f263522aSJoseph Koshy 			ps->ps_svcount = used = recordsize;
183f263522aSJoseph Koshy 			goto done;
184f263522aSJoseph Koshy 		}
185f263522aSJoseph Koshy 
186f263522aSJoseph Koshy 		/* header + a partial record is available */
187f263522aSJoseph Koshy 		bcopy(src, dst, avail - copylen);
188f263522aSJoseph Koshy 		ps->ps_svcount = used = avail;
189f263522aSJoseph Koshy 		ps->ps_state = PL_STATE_PARTIAL_RECORD;
190f263522aSJoseph Koshy 
191f263522aSJoseph Koshy 		break;
192f263522aSJoseph Koshy 
193f263522aSJoseph Koshy 	case PL_STATE_EXPECTING_HEADER:
194f263522aSJoseph Koshy 
195f263522aSJoseph Koshy 		/*
196f263522aSJoseph Koshy 		 * Transitions:
197f263522aSJoseph Koshy 		 *
198f263522aSJoseph Koshy 		 * Case C: avail+saved < headersize
199f263522aSJoseph Koshy 		 * 	-> 'expecting header'
200f263522aSJoseph Koshy 		 *
201f263522aSJoseph Koshy 		 * Case D: avail+saved >= headersize
202f263522aSJoseph Koshy 		 *    D.1: avail+saved < recordsize
203f263522aSJoseph Koshy 		 *    	-> 'partial record'
204f263522aSJoseph Koshy 		 *    D.2: avail+saved >= recordsize
205f263522aSJoseph Koshy 		 *    	-> 'new record'
206f263522aSJoseph Koshy 		 *    (see PARTIAL_RECORD handling below)
207f263522aSJoseph Koshy 		 */
208f263522aSJoseph Koshy 
209f263522aSJoseph Koshy 		if (avail + ps->ps_svcount < HEADERSIZE) {
210f263522aSJoseph Koshy 			bcopy(src, dst, avail);
211f263522aSJoseph Koshy 			ps->ps_svcount += avail;
212f263522aSJoseph Koshy 			used = avail;
213f263522aSJoseph Koshy 			break;
214f263522aSJoseph Koshy 		}
215f263522aSJoseph Koshy 
216f263522aSJoseph Koshy 		used = copylen = HEADERSIZE - ps->ps_svcount;
217f263522aSJoseph Koshy 		bcopy(src, dst, copylen);
218f263522aSJoseph Koshy 		src += copylen;
219f263522aSJoseph Koshy 		dst += copylen;
220f263522aSJoseph Koshy 		avail -= copylen;
221f263522aSJoseph Koshy 		ps->ps_svcount += copylen;
222f263522aSJoseph Koshy 
223f263522aSJoseph Koshy 		/*FALLTHROUGH*/
224f263522aSJoseph Koshy 
225f263522aSJoseph Koshy 	case PL_STATE_PARTIAL_RECORD:
226f263522aSJoseph Koshy 
227f263522aSJoseph Koshy 		/*
228f263522aSJoseph Koshy 		 * Transitions:
229f263522aSJoseph Koshy 		 *
230f263522aSJoseph Koshy 		 * Case E: avail+saved < recordsize
231f263522aSJoseph Koshy 		 * 	-> 'partial record'
232f263522aSJoseph Koshy 		 *
233f263522aSJoseph Koshy 		 * Case F: avail+saved >= recordsize
234f263522aSJoseph Koshy 		 * 	-> 'new record'
235f263522aSJoseph Koshy 		 */
236f263522aSJoseph Koshy 
237f263522aSJoseph Koshy 		h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
238f263522aSJoseph Koshy 		recordsize = PMCLOG_HEADER_TO_LENGTH(h);
239f263522aSJoseph Koshy 
240f263522aSJoseph Koshy 		if (recordsize <= 0)
241f263522aSJoseph Koshy 			goto error;
242f263522aSJoseph Koshy 
243f263522aSJoseph Koshy 		if (avail + ps->ps_svcount < recordsize) {
244f263522aSJoseph Koshy 			copylen = avail;
245f263522aSJoseph Koshy 			ps->ps_state = PL_STATE_PARTIAL_RECORD;
246f263522aSJoseph Koshy 		} else {
247f263522aSJoseph Koshy 			copylen = recordsize - ps->ps_svcount;
248f263522aSJoseph Koshy 			ps->ps_state = PL_STATE_NEW_RECORD;
249f263522aSJoseph Koshy 		}
250f263522aSJoseph Koshy 
251f263522aSJoseph Koshy 		bcopy(src, dst, copylen);
252f263522aSJoseph Koshy 		ps->ps_svcount += copylen;
253f263522aSJoseph Koshy 		used += copylen;
254f263522aSJoseph Koshy 		break;
255f263522aSJoseph Koshy 
256f263522aSJoseph Koshy 	default:
257f263522aSJoseph Koshy 		goto error;
258f263522aSJoseph Koshy 	}
259f263522aSJoseph Koshy 
260f263522aSJoseph Koshy  done:
261f263522aSJoseph Koshy 	*data += used;
262f263522aSJoseph Koshy 	*len  -= used;
263f263522aSJoseph Koshy 	return ps->ps_state;
264f263522aSJoseph Koshy 
265f263522aSJoseph Koshy  error:
266f263522aSJoseph Koshy 	ps->ps_state = PL_STATE_ERROR;
267f263522aSJoseph Koshy 	return ps->ps_state;
268f263522aSJoseph Koshy }
269f263522aSJoseph Koshy 
270f263522aSJoseph Koshy /*
271f263522aSJoseph Koshy  * Get an event from the stream pointed to by '*data'.  '*len'
272f263522aSJoseph Koshy  * indicates the number of bytes available to parse.  Arguments
273f263522aSJoseph Koshy  * '*data' and '*len' are updated to indicate the number of bytes
274f263522aSJoseph Koshy  * consumed.
275f263522aSJoseph Koshy  */
276f263522aSJoseph Koshy 
277f263522aSJoseph Koshy static int
278f263522aSJoseph Koshy pmclog_get_event(void *cookie, char **data, ssize_t *len,
279f263522aSJoseph Koshy     struct pmclog_ev *ev)
280f263522aSJoseph Koshy {
281f263522aSJoseph Koshy 	int evlen, pathlen;
282*959826caSMatt Macy 	uint32_t h, *le, npc, noop;
283f263522aSJoseph Koshy 	enum pmclog_parser_state e;
284f263522aSJoseph Koshy 	struct pmclog_parse_state *ps;
285f263522aSJoseph Koshy 
286f263522aSJoseph Koshy 	ps = (struct pmclog_parse_state *) cookie;
287f263522aSJoseph Koshy 
288f263522aSJoseph Koshy 	assert(ps->ps_state != PL_STATE_ERROR);
289f263522aSJoseph Koshy 
290f263522aSJoseph Koshy 	if ((e = pmclog_get_record(ps,data,len)) == PL_STATE_ERROR) {
291f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_ERROR;
292*959826caSMatt Macy 		printf("state error\n");
293f263522aSJoseph Koshy 		return -1;
294f263522aSJoseph Koshy 	}
295f263522aSJoseph Koshy 
296f263522aSJoseph Koshy 	if (e != PL_STATE_NEW_RECORD) {
297f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_REQUIRE_DATA;
298f263522aSJoseph Koshy 		return -1;
299f263522aSJoseph Koshy 	}
300f263522aSJoseph Koshy 
301f263522aSJoseph Koshy 	PMCLOG_INITIALIZE_READER(le, ps->ps_saved);
302f263522aSJoseph Koshy 
303f263522aSJoseph Koshy 	PMCLOG_READ32(le,h);
304f263522aSJoseph Koshy 
305f263522aSJoseph Koshy 	if (!PMCLOG_HEADER_CHECK_MAGIC(h)) {
306*959826caSMatt Macy 		printf("bad magic\n");
307f263522aSJoseph Koshy 		ps->ps_state = PL_STATE_ERROR;
308f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_ERROR;
309f263522aSJoseph Koshy 		return -1;
310f263522aSJoseph Koshy 	}
311f263522aSJoseph Koshy 
312f263522aSJoseph Koshy 	/* copy out the time stamp */
313f263522aSJoseph Koshy 	PMCLOG_READ32(le,ev->pl_ts.tv_sec);
314f263522aSJoseph Koshy 	PMCLOG_READ32(le,ev->pl_ts.tv_nsec);
315f263522aSJoseph Koshy 
316f263522aSJoseph Koshy 	evlen = PMCLOG_HEADER_TO_LENGTH(h);
317f263522aSJoseph Koshy 
318f263522aSJoseph Koshy #define	PMCLOG_GET_PATHLEN(P,E,TYPE) do {				\
319f263522aSJoseph Koshy 		(P) = (E) - offsetof(struct TYPE, pl_pathname);		\
320f263522aSJoseph Koshy 		if ((P) > PATH_MAX || (P) < 0)				\
321f263522aSJoseph Koshy 			goto error;					\
322f263522aSJoseph Koshy 	} while (0)
323f263522aSJoseph Koshy 
324c5e73985SJoseph Koshy #define	PMCLOG_GET_CALLCHAIN_SIZE(SZ,E) do {				\
325c5e73985SJoseph Koshy 		(SZ) = ((E) - offsetof(struct pmclog_callchain, pl_pc))	\
326c5e73985SJoseph Koshy 			/ sizeof(uintfptr_t);				\
327c5e73985SJoseph Koshy 	} while (0);
328c5e73985SJoseph Koshy 
329f263522aSJoseph Koshy 	switch (ev->pl_type = PMCLOG_HEADER_TO_TYPE(h)) {
330c5e73985SJoseph Koshy 	case PMCLOG_TYPE_CALLCHAIN:
331c5e73985SJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pid);
3320b5dc7f6SMatt Macy 		PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_tid);
333c5e73985SJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pmcid);
334c5e73985SJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_cpuflags);
3350b5dc7f6SMatt Macy 		PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_cpuflags2);
336c5e73985SJoseph Koshy 		PMCLOG_GET_CALLCHAIN_SIZE(ev->pl_u.pl_cc.pl_npc,evlen);
337c5e73985SJoseph Koshy 		for (npc = 0; npc < ev->pl_u.pl_cc.pl_npc; npc++)
338c5e73985SJoseph Koshy 			PMCLOG_READADDR(le,ev->pl_u.pl_cc.pl_pc[npc]);
339c5e73985SJoseph Koshy 		for (;npc < PMC_CALLCHAIN_DEPTH_MAX; npc++)
340c5e73985SJoseph Koshy 			ev->pl_u.pl_cc.pl_pc[npc] = (uintfptr_t) 0;
341c5e73985SJoseph Koshy 		break;
342f263522aSJoseph Koshy 	case PMCLOG_TYPE_CLOSELOG:
3439f4f1d4dSFabien Thomas 		ev->pl_state = PMCLOG_EOF;
3449f4f1d4dSFabien Thomas 		return (-1);
345f263522aSJoseph Koshy 	case PMCLOG_TYPE_DROPNOTIFY:
346f263522aSJoseph Koshy 		/* nothing to do */
347f263522aSJoseph Koshy 		break;
348f263522aSJoseph Koshy 	case PMCLOG_TYPE_INITIALIZE:
349f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_i.pl_version);
350f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_i.pl_arch);
351f263522aSJoseph Koshy 		ps->ps_version = ev->pl_u.pl_i.pl_version;
352f263522aSJoseph Koshy 		ps->ps_arch = ev->pl_u.pl_i.pl_arch;
353f263522aSJoseph Koshy 		ps->ps_initialized = 1;
354f263522aSJoseph Koshy 		break;
35549874f6eSJoseph Koshy 	case PMCLOG_TYPE_MAP_IN:
35649874f6eSJoseph Koshy 		PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_map_in);
35749874f6eSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_mi.pl_pid);
35849874f6eSJoseph Koshy 		PMCLOG_READADDR(le,ev->pl_u.pl_mi.pl_start);
35949874f6eSJoseph Koshy 		PMCLOG_READSTRING(le, ev->pl_u.pl_mi.pl_pathname, pathlen);
36049874f6eSJoseph Koshy 		break;
36149874f6eSJoseph Koshy 	case PMCLOG_TYPE_MAP_OUT:
36249874f6eSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_mo.pl_pid);
36349874f6eSJoseph Koshy 		PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_start);
36449874f6eSJoseph Koshy 		PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_end);
365f263522aSJoseph Koshy 		break;
366f263522aSJoseph Koshy 	case PMCLOG_TYPE_PMCALLOCATE:
367f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_a.pl_pmcid);
368f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_a.pl_event);
369f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_a.pl_flags);
370*959826caSMatt Macy 		PMCLOG_READ32(le,noop);
371*959826caSMatt Macy 		ev->pl_u.pl_a.pl_evname = pmu_event_get_by_idx(ev->pl_u.pl_a.pl_event);
372*959826caSMatt Macy 		if (ev->pl_u.pl_a.pl_evname != NULL)
373*959826caSMatt Macy 			break;
374*959826caSMatt Macy 		else if ((ev->pl_u.pl_a.pl_evname =
3750cfab8ddSJoseph Koshy 		    _pmc_name_of_event(ev->pl_u.pl_a.pl_event, ps->ps_arch))
376*959826caSMatt Macy 		    == NULL) {
377*959826caSMatt Macy 			printf("unknown event\n");
378f263522aSJoseph Koshy 			goto error;
379*959826caSMatt Macy 		}
380f263522aSJoseph Koshy 		break;
381f5f9340bSFabien Thomas 	case PMCLOG_TYPE_PMCALLOCATEDYN:
382f5f9340bSFabien Thomas 		PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_pmcid);
383f5f9340bSFabien Thomas 		PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_event);
384f5f9340bSFabien Thomas 		PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_flags);
385f5f9340bSFabien Thomas 		PMCLOG_READSTRING(le,ev->pl_u.pl_ad.pl_evname,PMC_NAME_MAX);
386f5f9340bSFabien Thomas 		break;
387f263522aSJoseph Koshy 	case PMCLOG_TYPE_PMCATTACH:
388f263522aSJoseph Koshy 		PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_pmcattach);
389f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pmcid);
390f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pid);
391f263522aSJoseph Koshy 		PMCLOG_READSTRING(le,ev->pl_u.pl_t.pl_pathname,pathlen);
392f263522aSJoseph Koshy 		break;
393f263522aSJoseph Koshy 	case PMCLOG_TYPE_PMCDETACH:
394f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pmcid);
395f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pid);
396f263522aSJoseph Koshy 		break;
397f263522aSJoseph Koshy 	case PMCLOG_TYPE_PROCCSW:
398f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pmcid);
399f263522aSJoseph Koshy 		PMCLOG_READ64(le,ev->pl_u.pl_c.pl_value);
400f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pid);
4010b5dc7f6SMatt Macy 		PMCLOG_READ32(le,ev->pl_u.pl_c.pl_tid);
402f263522aSJoseph Koshy 		break;
403f263522aSJoseph Koshy 	case PMCLOG_TYPE_PROCEXEC:
404f263522aSJoseph Koshy 		PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_procexec);
405f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pid);
4065506ceb8SMatt Macy 		PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pmcid);
407*959826caSMatt Macy 		PMCLOG_READ32(le,noop);
408*959826caSMatt Macy 		PMCLOG_READADDR(le,ev->pl_u.pl_x.pl_entryaddr);
409f263522aSJoseph Koshy 		PMCLOG_READSTRING(le,ev->pl_u.pl_x.pl_pathname,pathlen);
410f263522aSJoseph Koshy 		break;
411f263522aSJoseph Koshy 	case PMCLOG_TYPE_PROCEXIT:
412f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pmcid);
4135506ceb8SMatt Macy 		PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pid);
414*959826caSMatt Macy 		PMCLOG_READ32(le,noop);
415*959826caSMatt Macy 		PMCLOG_READ64(le,ev->pl_u.pl_e.pl_value);
416f263522aSJoseph Koshy 		break;
417f263522aSJoseph Koshy 	case PMCLOG_TYPE_PROCFORK:
418f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_f.pl_oldpid);
419f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_f.pl_newpid);
420f263522aSJoseph Koshy 		break;
421f263522aSJoseph Koshy 	case PMCLOG_TYPE_SYSEXIT:
422f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_se.pl_pid);
423f263522aSJoseph Koshy 		break;
424f263522aSJoseph Koshy 	case PMCLOG_TYPE_USERDATA:
425f263522aSJoseph Koshy 		PMCLOG_READ32(le,ev->pl_u.pl_u.pl_userdata);
426f263522aSJoseph Koshy 		break;
427f263522aSJoseph Koshy 	default:	/* unknown record type */
428f263522aSJoseph Koshy 		ps->ps_state = PL_STATE_ERROR;
429f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_ERROR;
430c5e73985SJoseph Koshy 		return (-1);
431f263522aSJoseph Koshy 	}
432f263522aSJoseph Koshy 
433f263522aSJoseph Koshy 	ev->pl_offset = (ps->ps_offset += evlen);
434f263522aSJoseph Koshy 	ev->pl_count  = (ps->ps_count += 1);
435f263522aSJoseph Koshy 	ev->pl_state = PMCLOG_OK;
436f263522aSJoseph Koshy 	return 0;
437f263522aSJoseph Koshy 
438f263522aSJoseph Koshy  error:
439f263522aSJoseph Koshy 	ev->pl_state = PMCLOG_ERROR;
440f263522aSJoseph Koshy 	ps->ps_state = PL_STATE_ERROR;
441f263522aSJoseph Koshy 	return -1;
442f263522aSJoseph Koshy }
443f263522aSJoseph Koshy 
444f263522aSJoseph Koshy /*
445f263522aSJoseph Koshy  * Extract and return the next event from the byte stream.
446f263522aSJoseph Koshy  *
447f263522aSJoseph Koshy  * Returns 0 and sets the event's state to PMCLOG_OK in case an event
448f263522aSJoseph Koshy  * was successfully parsed.  Otherwise this function returns -1 and
449f263522aSJoseph Koshy  * sets the event's state to one of PMCLOG_REQUIRE_DATA (if more data
450f263522aSJoseph Koshy  * is needed) or PMCLOG_EOF (if an EOF was seen) or PMCLOG_ERROR if
451f263522aSJoseph Koshy  * a parse error was encountered.
452f263522aSJoseph Koshy  */
453f263522aSJoseph Koshy 
454f263522aSJoseph Koshy int
455f263522aSJoseph Koshy pmclog_read(void *cookie, struct pmclog_ev *ev)
456f263522aSJoseph Koshy {
45782c83e34SJoseph Koshy 	int retval;
458f263522aSJoseph Koshy 	ssize_t nread;
459f263522aSJoseph Koshy 	struct pmclog_parse_state *ps;
460f263522aSJoseph Koshy 
461f263522aSJoseph Koshy 	ps = (struct pmclog_parse_state *) cookie;
462f263522aSJoseph Koshy 
463f263522aSJoseph Koshy 	if (ps->ps_state == PL_STATE_ERROR) {
464f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_ERROR;
465f263522aSJoseph Koshy 		return -1;
466f263522aSJoseph Koshy 	}
467f263522aSJoseph Koshy 
468f263522aSJoseph Koshy 	/*
469f263522aSJoseph Koshy 	 * If there isn't enough data left for a new event try and get
470f263522aSJoseph Koshy 	 * more data.
471f263522aSJoseph Koshy 	 */
472f263522aSJoseph Koshy 	if (ps->ps_len == 0) {
473f263522aSJoseph Koshy 		ev->pl_state = PMCLOG_REQUIRE_DATA;
474f263522aSJoseph Koshy 
475f263522aSJoseph Koshy 		/*
476f263522aSJoseph Koshy 		 * If we have a valid file descriptor to read from, attempt
477f263522aSJoseph Koshy 		 * to read from that.  This read may return with an error,
478f263522aSJoseph Koshy 		 * (which may be EAGAIN or other recoverable error), or
479f263522aSJoseph Koshy 		 * can return EOF.
480f263522aSJoseph Koshy 		 */
481f263522aSJoseph Koshy 		if (ps->ps_fd != PMCLOG_FD_NONE) {
48282c83e34SJoseph Koshy 		refill:
483f263522aSJoseph Koshy 			nread = read(ps->ps_fd, ps->ps_buffer,
484f263522aSJoseph Koshy 			    PMCLOG_BUFFER_SIZE);
485f263522aSJoseph Koshy 
486f263522aSJoseph Koshy 			if (nread <= 0) {
48715139246SJoseph Koshy 				if (nread == 0)
48815139246SJoseph Koshy 					ev->pl_state = PMCLOG_EOF;
48915139246SJoseph Koshy 				else if (errno != EAGAIN) /* not restartable */
49015139246SJoseph Koshy 					ev->pl_state = PMCLOG_ERROR;
491f263522aSJoseph Koshy 				return -1;
492f263522aSJoseph Koshy 			}
493f263522aSJoseph Koshy 
494f263522aSJoseph Koshy 			ps->ps_len = nread;
495f263522aSJoseph Koshy 			ps->ps_data = ps->ps_buffer;
496*959826caSMatt Macy 		} else {
497f263522aSJoseph Koshy 			return -1;
498f263522aSJoseph Koshy 		}
499*959826caSMatt Macy 	}
500f263522aSJoseph Koshy 
501f263522aSJoseph Koshy 	assert(ps->ps_len > 0);
502f263522aSJoseph Koshy 
50382c83e34SJoseph Koshy 
50482c83e34SJoseph Koshy 	 /* Retrieve one event from the byte stream. */
50582c83e34SJoseph Koshy 	retval = pmclog_get_event(ps, &ps->ps_data, &ps->ps_len, ev);
506f263522aSJoseph Koshy 	/*
50782c83e34SJoseph Koshy 	 * If we need more data and we have a configured fd, try read
50882c83e34SJoseph Koshy 	 * from it.
509f263522aSJoseph Koshy 	 */
51082c83e34SJoseph Koshy 	if (retval < 0 && ev->pl_state == PMCLOG_REQUIRE_DATA &&
51182c83e34SJoseph Koshy 	    ps->ps_fd != -1) {
51282c83e34SJoseph Koshy 		assert(ps->ps_len == 0);
51382c83e34SJoseph Koshy 		goto refill;
51482c83e34SJoseph Koshy 	}
51582c83e34SJoseph Koshy 
51682c83e34SJoseph Koshy 	return retval;
517f263522aSJoseph Koshy }
518f263522aSJoseph Koshy 
519f263522aSJoseph Koshy /*
520f263522aSJoseph Koshy  * Feed data to a memory based parser.
521f263522aSJoseph Koshy  *
522f263522aSJoseph Koshy  * The memory area pointed to by 'data' needs to be valid till the
523f263522aSJoseph Koshy  * next error return from pmclog_next_event().
524f263522aSJoseph Koshy  */
525f263522aSJoseph Koshy 
526f263522aSJoseph Koshy int
527f263522aSJoseph Koshy pmclog_feed(void *cookie, char *data, int len)
528f263522aSJoseph Koshy {
529f263522aSJoseph Koshy 	struct pmclog_parse_state *ps;
530f263522aSJoseph Koshy 
531f263522aSJoseph Koshy 	ps = (struct pmclog_parse_state *) cookie;
532f263522aSJoseph Koshy 
533f263522aSJoseph Koshy 	if (len < 0 ||		/* invalid length */
534f263522aSJoseph Koshy 	    ps->ps_buffer ||	/* called for a file parser */
535f263522aSJoseph Koshy 	    ps->ps_len != 0)	/* unnecessary call */
536f263522aSJoseph Koshy 		return -1;
537f263522aSJoseph Koshy 
538f263522aSJoseph Koshy 	ps->ps_data = data;
539f263522aSJoseph Koshy 	ps->ps_len  = len;
540f263522aSJoseph Koshy 
541f263522aSJoseph Koshy 	return 0;
542f263522aSJoseph Koshy }
543f263522aSJoseph Koshy 
544f263522aSJoseph Koshy /*
545f263522aSJoseph Koshy  * Allocate and initialize parser state.
546f263522aSJoseph Koshy  */
547f263522aSJoseph Koshy 
548f263522aSJoseph Koshy void *
549f263522aSJoseph Koshy pmclog_open(int fd)
550f263522aSJoseph Koshy {
551f263522aSJoseph Koshy 	struct pmclog_parse_state *ps;
552f263522aSJoseph Koshy 
553f263522aSJoseph Koshy 	if ((ps = (struct pmclog_parse_state *) malloc(sizeof(*ps))) == NULL)
554f263522aSJoseph Koshy 		return NULL;
555f263522aSJoseph Koshy 
556f263522aSJoseph Koshy 	ps->ps_state = PL_STATE_NEW_RECORD;
557f263522aSJoseph Koshy 	ps->ps_arch = -1;
558f263522aSJoseph Koshy 	ps->ps_initialized = 0;
559f263522aSJoseph Koshy 	ps->ps_count = 0;
560f263522aSJoseph Koshy 	ps->ps_offset = (off_t) 0;
561f263522aSJoseph Koshy 	bzero(&ps->ps_saved, sizeof(ps->ps_saved));
562f263522aSJoseph Koshy 	ps->ps_svcount = 0;
563f263522aSJoseph Koshy 	ps->ps_fd    = fd;
564f263522aSJoseph Koshy 	ps->ps_data  = NULL;
565f263522aSJoseph Koshy 	ps->ps_buffer = NULL;
566f263522aSJoseph Koshy 	ps->ps_len   = 0;
567f263522aSJoseph Koshy 
568f263522aSJoseph Koshy 	/* allocate space for a work area */
569f263522aSJoseph Koshy 	if (ps->ps_fd != PMCLOG_FD_NONE) {
570d66caf62SFabien Thomas 		if ((ps->ps_buffer = malloc(PMCLOG_BUFFER_SIZE)) == NULL) {
571d66caf62SFabien Thomas 			free(ps);
572f263522aSJoseph Koshy 			return NULL;
573f263522aSJoseph Koshy 		}
574d66caf62SFabien Thomas 	}
575f263522aSJoseph Koshy 
576f263522aSJoseph Koshy 	return ps;
577f263522aSJoseph Koshy }
578f263522aSJoseph Koshy 
579f263522aSJoseph Koshy 
580f263522aSJoseph Koshy /*
581f263522aSJoseph Koshy  * Free up parser state.
582f263522aSJoseph Koshy  */
583f263522aSJoseph Koshy 
584f263522aSJoseph Koshy void
585f263522aSJoseph Koshy pmclog_close(void *cookie)
586f263522aSJoseph Koshy {
587f263522aSJoseph Koshy 	struct pmclog_parse_state *ps;
588f263522aSJoseph Koshy 
589f263522aSJoseph Koshy 	ps = (struct pmclog_parse_state *) cookie;
590f263522aSJoseph Koshy 
591f263522aSJoseph Koshy 	if (ps->ps_buffer)
592f263522aSJoseph Koshy 		free(ps->ps_buffer);
593f263522aSJoseph Koshy 
594f263522aSJoseph Koshy 	free(ps);
595f263522aSJoseph Koshy }
596