2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2005-2007 Joseph Koshy
5 * Copyright (c) 2007 The FreeBSD Foundation
8 * Portions of this software were developed by A. Joseph Koshy under
9 * sponsorship from the FreeBSD Foundation and Google, Inc.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include <sys/param.h>
38 #include <sys/pmclog.h>
51 #include <machine/pmc_mdep.h>
53 #include "libpmcinternal.h"
55 #define PMCLOG_BUFFER_SIZE 512*1024
60 * The pmclog(3) API is oriented towards parsing an event stream in
61 * "realtime", i.e., from an data source that may or may not preserve
62 * record boundaries -- for example when the data source is elsewhere
63 * on a network. The API allows data to be fed into the parser zero
64 * or more bytes at a time.
66 * The state for a log file parser is maintained in a 'struct
67 * pmclog_parse_state'. Parser invocations are done by calling
68 * 'pmclog_read()'; this function will inform the caller when a
69 * complete event is parsed.
71 * The parser first assembles a complete log file event in an internal
72 * work area (see "ps_saved" below). Once a complete log file event
73 * is read, the parser then parses it and converts it to an event
74 * descriptor usable by the client. We could possibly avoid this two
75 * step process by directly parsing the input log to set fields in the
76 * event record. However the parser's state machine would get
77 * insanely complicated, and this code is unlikely to be used in
78 * performance critical paths.
81 #define PMCLOG_HEADER_FROM_SAVED_STATE(PS) \
82 (* ((uint32_t *) &(PS)->ps_saved))
84 #define PMCLOG_INITIALIZE_READER(LE,A) LE = (uint32_t *) &(A)
85 #define PMCLOG_SKIP32(LE) (LE)++
86 #define PMCLOG_READ32(LE,V) do { \
89 #define PMCLOG_READ64(LE,V) do { \
91 _v = (uint64_t) *(LE)++; \
92 _v |= ((uint64_t) *(LE)++) << 32; \
96 #define PMCLOG_READSTRING(LE,DST,LEN) strlcpy((DST), (char *) (LE), (LEN))
99 * Assemble a log record from '*len' octets starting from address '*data'.
100 * Update 'data' and 'len' to reflect the number of bytes consumed.
102 * '*data' is potentially an unaligned address and '*len' octets may
103 * not be enough to complete a event record.
106 static enum pmclog_parser_state
107 pmclog_get_record(struct pmclog_parse_state *ps, char **data, ssize_t *len)
109 int avail, copylen, recordsize, used;
111 const int HEADERSIZE = sizeof(uint32_t);
114 if ((avail = *len) <= 0)
115 return (ps->ps_state = PL_STATE_ERROR);
120 if (ps->ps_state == PL_STATE_NEW_RECORD)
123 dst = (char *) &ps->ps_saved + ps->ps_svcount;
125 switch (ps->ps_state) {
126 case PL_STATE_NEW_RECORD:
131 * Case A: avail < headersize
132 * -> 'expecting header'
134 * Case B: avail >= headersize
135 * B.1: avail < recordsize
136 * -> 'partial record'
137 * B.2: avail >= recordsize
141 copylen = avail < HEADERSIZE ? avail : HEADERSIZE;
142 bcopy(src, dst, copylen);
143 ps->ps_svcount = used = copylen;
145 if (copylen < HEADERSIZE) {
146 ps->ps_state = PL_STATE_EXPECTING_HEADER;
153 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
154 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
159 if (recordsize <= avail) { /* full record available */
160 bcopy(src, dst, recordsize - copylen);
161 ps->ps_svcount = used = recordsize;
165 /* header + a partial record is available */
166 bcopy(src, dst, avail - copylen);
167 ps->ps_svcount = used = avail;
168 ps->ps_state = PL_STATE_PARTIAL_RECORD;
172 case PL_STATE_EXPECTING_HEADER:
177 * Case C: avail+saved < headersize
178 * -> 'expecting header'
180 * Case D: avail+saved >= headersize
181 * D.1: avail+saved < recordsize
182 * -> 'partial record'
183 * D.2: avail+saved >= recordsize
185 * (see PARTIAL_RECORD handling below)
188 if (avail + ps->ps_svcount < HEADERSIZE) {
189 bcopy(src, dst, avail);
190 ps->ps_svcount += avail;
195 used = copylen = HEADERSIZE - ps->ps_svcount;
196 bcopy(src, dst, copylen);
200 ps->ps_svcount += copylen;
204 case PL_STATE_PARTIAL_RECORD:
209 * Case E: avail+saved < recordsize
210 * -> 'partial record'
212 * Case F: avail+saved >= recordsize
216 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
217 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
222 if (avail + ps->ps_svcount < recordsize) {
224 ps->ps_state = PL_STATE_PARTIAL_RECORD;
226 copylen = recordsize - ps->ps_svcount;
227 ps->ps_state = PL_STATE_NEW_RECORD;
230 bcopy(src, dst, copylen);
231 ps->ps_svcount += copylen;
245 ps->ps_state = PL_STATE_ERROR;
250 * Get an event from the stream pointed to by '*data'. '*len'
251 * indicates the number of bytes available to parse. Arguments
252 * '*data' and '*len' are updated to indicate the number of bytes
257 pmclog_get_event(void *cookie, char **data, ssize_t *len,
258 struct pmclog_ev *ev)
261 uint32_t h, *le, npc;
262 enum pmclog_parser_state e;
263 struct pmclog_parse_state *ps;
264 struct pmclog_header *ph;
266 ps = (struct pmclog_parse_state *) cookie;
268 assert(ps->ps_state != PL_STATE_ERROR);
270 if ((e = pmclog_get_record(ps,data,len)) == PL_STATE_ERROR) {
271 ev->pl_state = PMCLOG_ERROR;
272 printf("state error\n");
276 if (e != PL_STATE_NEW_RECORD) {
277 ev->pl_state = PMCLOG_REQUIRE_DATA;
281 PMCLOG_INITIALIZE_READER(le, ps->ps_saved);
283 ph = (struct pmclog_header *)(uintptr_t)le;
286 if (!PMCLOG_HEADER_CHECK_MAGIC(h)) {
287 printf("bad magic\n");
288 ps->ps_state = PL_STATE_ERROR;
289 ev->pl_state = PMCLOG_ERROR;
293 /* copy out the time stamp */
294 ev->pl_ts.tv_sec = ph->pl_tsc;
297 evlen = PMCLOG_HEADER_TO_LENGTH(h);
299 #define PMCLOG_GET_PATHLEN(P,E,TYPE) do { \
300 (P) = (E) - offsetof(struct TYPE, pl_pathname); \
301 if ((P) > PATH_MAX || (P) < 0) \
305 #define PMCLOG_GET_CALLCHAIN_SIZE(SZ,E) do { \
306 (SZ) = ((E) - offsetof(struct pmclog_callchain, pl_pc)) \
307 / sizeof(uintfptr_t); \
310 switch (ev->pl_type = PMCLOG_HEADER_TO_TYPE(h)) {
311 case PMCLOG_TYPE_CALLCHAIN:
312 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pid);
313 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_tid);
314 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pmcid);
315 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_cpuflags);
316 PMCLOG_GET_CALLCHAIN_SIZE(ev->pl_u.pl_cc.pl_npc,evlen);
317 for (npc = 0; npc < ev->pl_u.pl_cc.pl_npc; npc++)
318 PMCLOG_READADDR(le,ev->pl_u.pl_cc.pl_pc[npc]);
319 for (;npc < PMC_CALLCHAIN_DEPTH_MAX; npc++)
320 ev->pl_u.pl_cc.pl_pc[npc] = (uintfptr_t) 0;
322 case PMCLOG_TYPE_CLOSELOG:
323 ev->pl_state = PMCLOG_EOF;
325 case PMCLOG_TYPE_DROPNOTIFY:
328 case PMCLOG_TYPE_INITIALIZE:
329 PMCLOG_READ32(le,ev->pl_u.pl_i.pl_version);
330 PMCLOG_READ32(le,ev->pl_u.pl_i.pl_arch);
331 PMCLOG_READ64(le,ev->pl_u.pl_i.pl_tsc_freq);
332 memcpy(&ev->pl_u.pl_i.pl_ts, le, sizeof(struct timespec));
333 le += sizeof(struct timespec)/4;
334 PMCLOG_READSTRING(le, ev->pl_u.pl_i.pl_cpuid, PMC_CPUID_LEN);
335 memcpy(ev->pl_u.pl_i.pl_cpuid, le, PMC_CPUID_LEN);
336 ps->ps_cpuid = strdup(ev->pl_u.pl_i.pl_cpuid);
337 ps->ps_version = ev->pl_u.pl_i.pl_version;
338 ps->ps_arch = ev->pl_u.pl_i.pl_arch;
339 ps->ps_initialized = 1;
341 case PMCLOG_TYPE_MAP_IN:
342 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_map_in);
343 PMCLOG_READ32(le,ev->pl_u.pl_mi.pl_pid);
345 PMCLOG_READADDR(le,ev->pl_u.pl_mi.pl_start);
346 PMCLOG_READSTRING(le, ev->pl_u.pl_mi.pl_pathname, pathlen);
348 case PMCLOG_TYPE_MAP_OUT:
349 PMCLOG_READ32(le,ev->pl_u.pl_mo.pl_pid);
351 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_start);
352 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_end);
354 case PMCLOG_TYPE_PMCALLOCATE:
355 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_pmcid);
356 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_event);
357 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_flags);
359 PMCLOG_READ64(le,ev->pl_u.pl_a.pl_rate);
362 * Could be either a PMC event code or a PMU event index;
363 * assume that their encodings don't overlap (i.e. no PMU event
364 * table is more than 0x1000 entries) to distinguish them here.
365 * Otherwise pmc_pmu_event_get_by_idx will go out of bounds if
366 * given a PMC event code when it knows about that CPU.
368 * XXX: Ideally we'd have user flags to give us that context.
370 if (ev->pl_u.pl_a.pl_event < PMC_EVENT_FIRST)
371 ev->pl_u.pl_a.pl_evname =
372 pmc_pmu_event_get_by_idx(ps->ps_cpuid,
373 ev->pl_u.pl_a.pl_event);
374 else if (ev->pl_u.pl_a.pl_event <= PMC_EVENT_LAST)
375 ev->pl_u.pl_a.pl_evname =
376 _pmc_name_of_event(ev->pl_u.pl_a.pl_event,
379 ev->pl_u.pl_a.pl_evname = NULL;
380 if (ev->pl_u.pl_a.pl_evname == NULL) {
381 printf("unknown event\n");
385 case PMCLOG_TYPE_PMCALLOCATEDYN:
386 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_pmcid);
387 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_event);
388 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_flags);
390 PMCLOG_READSTRING(le,ev->pl_u.pl_ad.pl_evname,PMC_NAME_MAX);
392 case PMCLOG_TYPE_PMCATTACH:
393 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_pmcattach);
394 PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pmcid);
395 PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pid);
396 PMCLOG_READSTRING(le,ev->pl_u.pl_t.pl_pathname,pathlen);
398 case PMCLOG_TYPE_PMCDETACH:
399 PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pmcid);
400 PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pid);
402 case PMCLOG_TYPE_PROCCSW:
403 PMCLOG_READ64(le,ev->pl_u.pl_c.pl_value);
404 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pmcid);
405 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pid);
406 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_tid);
408 case PMCLOG_TYPE_PROCEXEC:
409 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_procexec);
410 PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pid);
411 PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pmcid);
412 PMCLOG_READADDR(le,ev->pl_u.pl_x.pl_baseaddr);
413 PMCLOG_READADDR(le,ev->pl_u.pl_x.pl_dynaddr);
414 PMCLOG_READSTRING(le,ev->pl_u.pl_x.pl_pathname,pathlen);
416 case PMCLOG_TYPE_PROCEXIT:
417 PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pmcid);
418 PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pid);
419 PMCLOG_READ64(le,ev->pl_u.pl_e.pl_value);
421 case PMCLOG_TYPE_PROCFORK:
422 PMCLOG_READ32(le,ev->pl_u.pl_f.pl_oldpid);
423 PMCLOG_READ32(le,ev->pl_u.pl_f.pl_newpid);
425 case PMCLOG_TYPE_SYSEXIT:
426 PMCLOG_READ32(le,ev->pl_u.pl_se.pl_pid);
428 case PMCLOG_TYPE_USERDATA:
429 PMCLOG_READ32(le,ev->pl_u.pl_u.pl_userdata);
431 case PMCLOG_TYPE_THR_CREATE:
432 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_tid);
433 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_pid);
434 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_flags);
436 memcpy(ev->pl_u.pl_tc.pl_tdname, le, MAXCOMLEN+1);
438 case PMCLOG_TYPE_THR_EXIT:
439 PMCLOG_READ32(le,ev->pl_u.pl_te.pl_tid);
441 case PMCLOG_TYPE_PROC_CREATE:
442 PMCLOG_READ32(le,ev->pl_u.pl_pc.pl_pid);
443 PMCLOG_READ32(le,ev->pl_u.pl_pc.pl_flags);
444 memcpy(ev->pl_u.pl_pc.pl_pcomm, le, MAXCOMLEN+1);
446 default: /* unknown record type */
447 ps->ps_state = PL_STATE_ERROR;
448 ev->pl_state = PMCLOG_ERROR;
452 ev->pl_offset = (ps->ps_offset += evlen);
453 ev->pl_count = (ps->ps_count += 1);
455 ev->pl_state = PMCLOG_OK;
459 ev->pl_state = PMCLOG_ERROR;
460 ps->ps_state = PL_STATE_ERROR;
465 * Extract and return the next event from the byte stream.
467 * Returns 0 and sets the event's state to PMCLOG_OK in case an event
468 * was successfully parsed. Otherwise this function returns -1 and
469 * sets the event's state to one of PMCLOG_REQUIRE_DATA (if more data
470 * is needed) or PMCLOG_EOF (if an EOF was seen) or PMCLOG_ERROR if
471 * a parse error was encountered.
475 pmclog_read(void *cookie, struct pmclog_ev *ev)
479 struct pmclog_parse_state *ps;
481 ps = (struct pmclog_parse_state *) cookie;
483 if (ps->ps_state == PL_STATE_ERROR) {
484 ev->pl_state = PMCLOG_ERROR;
489 * If there isn't enough data left for a new event try and get
492 if (ps->ps_len == 0) {
493 ev->pl_state = PMCLOG_REQUIRE_DATA;
496 * If we have a valid file descriptor to read from, attempt
497 * to read from that. This read may return with an error,
498 * (which may be EAGAIN or other recoverable error), or
501 if (ps->ps_fd != PMCLOG_FD_NONE) {
503 nread = read(ps->ps_fd, ps->ps_buffer,
508 ev->pl_state = PMCLOG_EOF;
509 else if (errno != EAGAIN) /* not restartable */
510 ev->pl_state = PMCLOG_ERROR;
515 ps->ps_data = ps->ps_buffer;
521 assert(ps->ps_len > 0);
524 /* Retrieve one event from the byte stream. */
525 retval = pmclog_get_event(ps, &ps->ps_data, &ps->ps_len, ev);
527 * If we need more data and we have a configured fd, try read
530 if (retval < 0 && ev->pl_state == PMCLOG_REQUIRE_DATA &&
532 assert(ps->ps_len == 0);
540 * Feed data to a memory based parser.
542 * The memory area pointed to by 'data' needs to be valid till the
543 * next error return from pmclog_next_event().
547 pmclog_feed(void *cookie, char *data, int len)
549 struct pmclog_parse_state *ps;
551 ps = (struct pmclog_parse_state *) cookie;
553 if (len < 0 || /* invalid length */
554 ps->ps_buffer || /* called for a file parser */
555 ps->ps_len != 0) /* unnecessary call */
565 * Allocate and initialize parser state.
571 struct pmclog_parse_state *ps;
573 if ((ps = (struct pmclog_parse_state *) malloc(sizeof(*ps))) == NULL)
576 ps->ps_state = PL_STATE_NEW_RECORD;
578 ps->ps_initialized = 0;
580 ps->ps_offset = (off_t) 0;
581 bzero(&ps->ps_saved, sizeof(ps->ps_saved));
586 ps->ps_buffer = NULL;
589 /* allocate space for a work area */
590 if (ps->ps_fd != PMCLOG_FD_NONE) {
591 if ((ps->ps_buffer = malloc(PMCLOG_BUFFER_SIZE)) == NULL) {
602 * Free up parser state.
606 pmclog_close(void *cookie)
608 struct pmclog_parse_state *ps;
610 ps = (struct pmclog_parse_state *) cookie;