1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2005-2007 Joseph Koshy
5 * Copyright (c) 2007 The FreeBSD Foundation
6 * All rights reserved.
7 *
8 * Portions of this software were developed by A. Joseph Koshy under
9 * sponsorship from the FreeBSD Foundation and Google, Inc.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
19 *
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
30 * SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD: stable/12/lib/libpmc/pmclog.c 334749 2018-06-07 02:03:22Z mmacy $");
35
36 #include <sys/param.h>
37 #include <sys/pmc.h>
38 #include <sys/pmclog.h>
39
40 #include <assert.h>
41 #include <errno.h>
42 #include <pmc.h>
43 #include <pmclog.h>
44 #include <stddef.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <strings.h>
48 #include <unistd.h>
49 #include <stdio.h>
50
51 #include <machine/pmc_mdep.h>
52
53 #include "libpmcinternal.h"
54
55 #define PMCLOG_BUFFER_SIZE 512*1024
56
57 /*
58 * API NOTES
59 *
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.
65 *
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.
70 *
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.
79 */
80
81 #define PMCLOG_HEADER_FROM_SAVED_STATE(PS) \
82 (* ((uint32_t *) &(PS)->ps_saved))
83
84 #define PMCLOG_INITIALIZE_READER(LE,A) LE = (uint32_t *) &(A)
85 #define PMCLOG_READ32(LE,V) do { \
86 (V) = *(LE)++; \
87 } while (0)
88 #define PMCLOG_READ64(LE,V) do { \
89 uint64_t _v; \
90 _v = (uint64_t) *(LE)++; \
91 _v |= ((uint64_t) *(LE)++) << 32; \
92 (V) = _v; \
93 } while (0)
94
95 #define PMCLOG_READSTRING(LE,DST,LEN) strlcpy((DST), (char *) (LE), (LEN))
96
97 /*
98 * Assemble a log record from '*len' octets starting from address '*data'.
99 * Update 'data' and 'len' to reflect the number of bytes consumed.
100 *
101 * '*data' is potentially an unaligned address and '*len' octets may
102 * not be enough to complete a event record.
103 */
104
105 static enum pmclog_parser_state
pmclog_get_record(struct pmclog_parse_state * ps,char ** data,ssize_t * len)106 pmclog_get_record(struct pmclog_parse_state *ps, char **data, ssize_t *len)
107 {
108 int avail, copylen, recordsize, used;
109 uint32_t h;
110 const int HEADERSIZE = sizeof(uint32_t);
111 char *src, *dst;
112
113 if ((avail = *len) <= 0)
114 return (ps->ps_state = PL_STATE_ERROR);
115
116 src = *data;
117 used = 0;
118
119 if (ps->ps_state == PL_STATE_NEW_RECORD)
120 ps->ps_svcount = 0;
121
122 dst = (char *) &ps->ps_saved + ps->ps_svcount;
123
124 switch (ps->ps_state) {
125 case PL_STATE_NEW_RECORD:
126
127 /*
128 * Transitions:
129 *
130 * Case A: avail < headersize
131 * -> 'expecting header'
132 *
133 * Case B: avail >= headersize
134 * B.1: avail < recordsize
135 * -> 'partial record'
136 * B.2: avail >= recordsize
137 * -> 'new record'
138 */
139
140 copylen = avail < HEADERSIZE ? avail : HEADERSIZE;
141 bcopy(src, dst, copylen);
142 ps->ps_svcount = used = copylen;
143
144 if (copylen < HEADERSIZE) {
145 ps->ps_state = PL_STATE_EXPECTING_HEADER;
146 goto done;
147 }
148
149 src += copylen;
150 dst += copylen;
151
152 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
153 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
154
155 if (recordsize <= 0)
156 goto error;
157
158 if (recordsize <= avail) { /* full record available */
159 bcopy(src, dst, recordsize - copylen);
160 ps->ps_svcount = used = recordsize;
161 goto done;
162 }
163
164 /* header + a partial record is available */
165 bcopy(src, dst, avail - copylen);
166 ps->ps_svcount = used = avail;
167 ps->ps_state = PL_STATE_PARTIAL_RECORD;
168
169 break;
170
171 case PL_STATE_EXPECTING_HEADER:
172
173 /*
174 * Transitions:
175 *
176 * Case C: avail+saved < headersize
177 * -> 'expecting header'
178 *
179 * Case D: avail+saved >= headersize
180 * D.1: avail+saved < recordsize
181 * -> 'partial record'
182 * D.2: avail+saved >= recordsize
183 * -> 'new record'
184 * (see PARTIAL_RECORD handling below)
185 */
186
187 if (avail + ps->ps_svcount < HEADERSIZE) {
188 bcopy(src, dst, avail);
189 ps->ps_svcount += avail;
190 used = avail;
191 break;
192 }
193
194 used = copylen = HEADERSIZE - ps->ps_svcount;
195 bcopy(src, dst, copylen);
196 src += copylen;
197 dst += copylen;
198 avail -= copylen;
199 ps->ps_svcount += copylen;
200
201 /*FALLTHROUGH*/
202
203 case PL_STATE_PARTIAL_RECORD:
204
205 /*
206 * Transitions:
207 *
208 * Case E: avail+saved < recordsize
209 * -> 'partial record'
210 *
211 * Case F: avail+saved >= recordsize
212 * -> 'new record'
213 */
214
215 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
216 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
217
218 if (recordsize <= 0)
219 goto error;
220
221 if (avail + ps->ps_svcount < recordsize) {
222 copylen = avail;
223 ps->ps_state = PL_STATE_PARTIAL_RECORD;
224 } else {
225 copylen = recordsize - ps->ps_svcount;
226 ps->ps_state = PL_STATE_NEW_RECORD;
227 }
228
229 bcopy(src, dst, copylen);
230 ps->ps_svcount += copylen;
231 used += copylen;
232 break;
233
234 default:
235 goto error;
236 }
237
238 done:
239 *data += used;
240 *len -= used;
241 return ps->ps_state;
242
243 error:
244 ps->ps_state = PL_STATE_ERROR;
245 return ps->ps_state;
246 }
247
248 /*
249 * Get an event from the stream pointed to by '*data'. '*len'
250 * indicates the number of bytes available to parse. Arguments
251 * '*data' and '*len' are updated to indicate the number of bytes
252 * consumed.
253 */
254
255 static int
pmclog_get_event(void * cookie,char ** data,ssize_t * len,struct pmclog_ev * ev)256 pmclog_get_event(void *cookie, char **data, ssize_t *len,
257 struct pmclog_ev *ev)
258 {
259 int evlen, pathlen;
260 uint32_t h, *le, npc, noop;
261 enum pmclog_parser_state e;
262 struct pmclog_parse_state *ps;
263 struct pmclog_header *ph;
264
265 ps = (struct pmclog_parse_state *) cookie;
266
267 assert(ps->ps_state != PL_STATE_ERROR);
268
269 if ((e = pmclog_get_record(ps,data,len)) == PL_STATE_ERROR) {
270 ev->pl_state = PMCLOG_ERROR;
271 printf("state error\n");
272 return -1;
273 }
274
275 if (e != PL_STATE_NEW_RECORD) {
276 ev->pl_state = PMCLOG_REQUIRE_DATA;
277 return -1;
278 }
279
280 PMCLOG_INITIALIZE_READER(le, ps->ps_saved);
281 ev->pl_data = le;
282 ph = (struct pmclog_header *)(uintptr_t)le;
283
284 h = ph->pl_header;
285 if (!PMCLOG_HEADER_CHECK_MAGIC(h)) {
286 printf("bad magic\n");
287 ps->ps_state = PL_STATE_ERROR;
288 ev->pl_state = PMCLOG_ERROR;
289 return -1;
290 }
291
292 /* copy out the time stamp */
293 ev->pl_ts.tv_sec = ph->pl_tsc;
294 le += sizeof(*ph)/4;
295
296 evlen = PMCLOG_HEADER_TO_LENGTH(h);
297
298 #define PMCLOG_GET_PATHLEN(P,E,TYPE) do { \
299 (P) = (E) - offsetof(struct TYPE, pl_pathname); \
300 if ((P) > PATH_MAX || (P) < 0) \
301 goto error; \
302 } while (0)
303
304 #define PMCLOG_GET_CALLCHAIN_SIZE(SZ,E) do { \
305 (SZ) = ((E) - offsetof(struct pmclog_callchain, pl_pc)) \
306 / sizeof(uintfptr_t); \
307 } while (0);
308
309 switch (ev->pl_type = PMCLOG_HEADER_TO_TYPE(h)) {
310 case PMCLOG_TYPE_CALLCHAIN:
311 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pid);
312 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_tid);
313 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_pmcid);
314 PMCLOG_READ32(le,ev->pl_u.pl_cc.pl_cpuflags);
315 PMCLOG_GET_CALLCHAIN_SIZE(ev->pl_u.pl_cc.pl_npc,evlen);
316 for (npc = 0; npc < ev->pl_u.pl_cc.pl_npc; npc++)
317 PMCLOG_READADDR(le,ev->pl_u.pl_cc.pl_pc[npc]);
318 for (;npc < PMC_CALLCHAIN_DEPTH_MAX; npc++)
319 ev->pl_u.pl_cc.pl_pc[npc] = (uintfptr_t) 0;
320 break;
321 case PMCLOG_TYPE_CLOSELOG:
322 ev->pl_state = PMCLOG_EOF;
323 return (-1);
324 case PMCLOG_TYPE_DROPNOTIFY:
325 /* nothing to do */
326 break;
327 case PMCLOG_TYPE_INITIALIZE:
328 PMCLOG_READ32(le,ev->pl_u.pl_i.pl_version);
329 PMCLOG_READ32(le,ev->pl_u.pl_i.pl_arch);
330 PMCLOG_READ64(le,ev->pl_u.pl_i.pl_tsc_freq);
331 memcpy(&ev->pl_u.pl_i.pl_ts, le, sizeof(struct timespec));
332 le += sizeof(struct timespec)/4;
333 PMCLOG_READSTRING(le, ev->pl_u.pl_i.pl_cpuid, PMC_CPUID_LEN);
334 memcpy(ev->pl_u.pl_i.pl_cpuid, le, PMC_CPUID_LEN);
335 ps->ps_cpuid = strdup(ev->pl_u.pl_i.pl_cpuid);
336 ps->ps_version = ev->pl_u.pl_i.pl_version;
337 ps->ps_arch = ev->pl_u.pl_i.pl_arch;
338 ps->ps_initialized = 1;
339 break;
340 case PMCLOG_TYPE_MAP_IN:
341 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_map_in);
342 PMCLOG_READ32(le,ev->pl_u.pl_mi.pl_pid);
343 PMCLOG_READ32(le,noop);
344 PMCLOG_READADDR(le,ev->pl_u.pl_mi.pl_start);
345 PMCLOG_READSTRING(le, ev->pl_u.pl_mi.pl_pathname, pathlen);
346 break;
347 case PMCLOG_TYPE_MAP_OUT:
348 PMCLOG_READ32(le,ev->pl_u.pl_mo.pl_pid);
349 PMCLOG_READ32(le,noop);
350 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_start);
351 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_end);
352 break;
353 case PMCLOG_TYPE_PMCALLOCATE:
354 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_pmcid);
355 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_event);
356 PMCLOG_READ32(le,ev->pl_u.pl_a.pl_flags);
357 PMCLOG_READ32(le,noop);
358 PMCLOG_READ64(le,ev->pl_u.pl_a.pl_rate);
359 ev->pl_u.pl_a.pl_evname = pmc_pmu_event_get_by_idx(ps->ps_cpuid, ev->pl_u.pl_a.pl_event);
360 if (ev->pl_u.pl_a.pl_evname != NULL)
361 break;
362 else if ((ev->pl_u.pl_a.pl_evname =
363 _pmc_name_of_event(ev->pl_u.pl_a.pl_event, ps->ps_arch))
364 == NULL) {
365 printf("unknown event\n");
366 goto error;
367 }
368 break;
369 case PMCLOG_TYPE_PMCALLOCATEDYN:
370 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_pmcid);
371 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_event);
372 PMCLOG_READ32(le,ev->pl_u.pl_ad.pl_flags);
373 PMCLOG_READ32(le,noop);
374 PMCLOG_READSTRING(le,ev->pl_u.pl_ad.pl_evname,PMC_NAME_MAX);
375 break;
376 case PMCLOG_TYPE_PMCATTACH:
377 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_pmcattach);
378 PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pmcid);
379 PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pid);
380 PMCLOG_READSTRING(le,ev->pl_u.pl_t.pl_pathname,pathlen);
381 break;
382 case PMCLOG_TYPE_PMCDETACH:
383 PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pmcid);
384 PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pid);
385 break;
386 case PMCLOG_TYPE_PROCCSW:
387 PMCLOG_READ64(le,ev->pl_u.pl_c.pl_value);
388 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pmcid);
389 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pid);
390 PMCLOG_READ32(le,ev->pl_u.pl_c.pl_tid);
391 break;
392 case PMCLOG_TYPE_PROCEXEC:
393 PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_procexec);
394 PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pid);
395 PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pmcid);
396 PMCLOG_READADDR(le,ev->pl_u.pl_x.pl_entryaddr);
397 PMCLOG_READSTRING(le,ev->pl_u.pl_x.pl_pathname,pathlen);
398 break;
399 case PMCLOG_TYPE_PROCEXIT:
400 PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pmcid);
401 PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pid);
402 PMCLOG_READ64(le,ev->pl_u.pl_e.pl_value);
403 break;
404 case PMCLOG_TYPE_PROCFORK:
405 PMCLOG_READ32(le,ev->pl_u.pl_f.pl_oldpid);
406 PMCLOG_READ32(le,ev->pl_u.pl_f.pl_newpid);
407 break;
408 case PMCLOG_TYPE_SYSEXIT:
409 PMCLOG_READ32(le,ev->pl_u.pl_se.pl_pid);
410 break;
411 case PMCLOG_TYPE_USERDATA:
412 PMCLOG_READ32(le,ev->pl_u.pl_u.pl_userdata);
413 break;
414 case PMCLOG_TYPE_THR_CREATE:
415 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_tid);
416 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_pid);
417 PMCLOG_READ32(le,ev->pl_u.pl_tc.pl_flags);
418 PMCLOG_READ32(le,noop);
419 memcpy(ev->pl_u.pl_tc.pl_tdname, le, MAXCOMLEN+1);
420 break;
421 case PMCLOG_TYPE_THR_EXIT:
422 PMCLOG_READ32(le,ev->pl_u.pl_te.pl_tid);
423 break;
424 case PMCLOG_TYPE_PROC_CREATE:
425 PMCLOG_READ32(le,ev->pl_u.pl_pc.pl_pid);
426 PMCLOG_READ32(le,ev->pl_u.pl_pc.pl_flags);
427 memcpy(ev->pl_u.pl_pc.pl_pcomm, le, MAXCOMLEN+1);
428 break;
429 default: /* unknown record type */
430 ps->ps_state = PL_STATE_ERROR;
431 ev->pl_state = PMCLOG_ERROR;
432 return (-1);
433 }
434
435 ev->pl_offset = (ps->ps_offset += evlen);
436 ev->pl_count = (ps->ps_count += 1);
437 ev->pl_len = evlen;
438 ev->pl_state = PMCLOG_OK;
439 return 0;
440
441 error:
442 ev->pl_state = PMCLOG_ERROR;
443 ps->ps_state = PL_STATE_ERROR;
444 return -1;
445 }
446
447 /*
448 * Extract and return the next event from the byte stream.
449 *
450 * Returns 0 and sets the event's state to PMCLOG_OK in case an event
451 * was successfully parsed. Otherwise this function returns -1 and
452 * sets the event's state to one of PMCLOG_REQUIRE_DATA (if more data
453 * is needed) or PMCLOG_EOF (if an EOF was seen) or PMCLOG_ERROR if
454 * a parse error was encountered.
455 */
456
457 int
pmclog_read(void * cookie,struct pmclog_ev * ev)458 pmclog_read(void *cookie, struct pmclog_ev *ev)
459 {
460 int retval;
461 ssize_t nread;
462 struct pmclog_parse_state *ps;
463
464 ps = (struct pmclog_parse_state *) cookie;
465
466 if (ps->ps_state == PL_STATE_ERROR) {
467 ev->pl_state = PMCLOG_ERROR;
468 return -1;
469 }
470
471 /*
472 * If there isn't enough data left for a new event try and get
473 * more data.
474 */
475 if (ps->ps_len == 0) {
476 ev->pl_state = PMCLOG_REQUIRE_DATA;
477
478 /*
479 * If we have a valid file descriptor to read from, attempt
480 * to read from that. This read may return with an error,
481 * (which may be EAGAIN or other recoverable error), or
482 * can return EOF.
483 */
484 if (ps->ps_fd != PMCLOG_FD_NONE) {
485 refill:
486 nread = read(ps->ps_fd, ps->ps_buffer,
487 PMCLOG_BUFFER_SIZE);
488
489 if (nread <= 0) {
490 if (nread == 0)
491 ev->pl_state = PMCLOG_EOF;
492 else if (errno != EAGAIN) /* not restartable */
493 ev->pl_state = PMCLOG_ERROR;
494 return -1;
495 }
496
497 ps->ps_len = nread;
498 ps->ps_data = ps->ps_buffer;
499 } else {
500 return -1;
501 }
502 }
503
504 assert(ps->ps_len > 0);
505
506
507 /* Retrieve one event from the byte stream. */
508 retval = pmclog_get_event(ps, &ps->ps_data, &ps->ps_len, ev);
509 /*
510 * If we need more data and we have a configured fd, try read
511 * from it.
512 */
513 if (retval < 0 && ev->pl_state == PMCLOG_REQUIRE_DATA &&
514 ps->ps_fd != -1) {
515 assert(ps->ps_len == 0);
516 goto refill;
517 }
518
519 return retval;
520 }
521
522 /*
523 * Feed data to a memory based parser.
524 *
525 * The memory area pointed to by 'data' needs to be valid till the
526 * next error return from pmclog_next_event().
527 */
528
529 int
pmclog_feed(void * cookie,char * data,int len)530 pmclog_feed(void *cookie, char *data, int len)
531 {
532 struct pmclog_parse_state *ps;
533
534 ps = (struct pmclog_parse_state *) cookie;
535
536 if (len < 0 || /* invalid length */
537 ps->ps_buffer || /* called for a file parser */
538 ps->ps_len != 0) /* unnecessary call */
539 return -1;
540
541 ps->ps_data = data;
542 ps->ps_len = len;
543
544 return 0;
545 }
546
547 /*
548 * Allocate and initialize parser state.
549 */
550
551 void *
pmclog_open(int fd)552 pmclog_open(int fd)
553 {
554 struct pmclog_parse_state *ps;
555
556 if ((ps = (struct pmclog_parse_state *) malloc(sizeof(*ps))) == NULL)
557 return NULL;
558
559 ps->ps_state = PL_STATE_NEW_RECORD;
560 ps->ps_arch = -1;
561 ps->ps_initialized = 0;
562 ps->ps_count = 0;
563 ps->ps_offset = (off_t) 0;
564 bzero(&ps->ps_saved, sizeof(ps->ps_saved));
565 ps->ps_cpuid = NULL;
566 ps->ps_svcount = 0;
567 ps->ps_fd = fd;
568 ps->ps_data = NULL;
569 ps->ps_buffer = NULL;
570 ps->ps_len = 0;
571
572 /* allocate space for a work area */
573 if (ps->ps_fd != PMCLOG_FD_NONE) {
574 if ((ps->ps_buffer = malloc(PMCLOG_BUFFER_SIZE)) == NULL) {
575 free(ps);
576 return NULL;
577 }
578 }
579
580 return ps;
581 }
582
583
584 /*
585 * Free up parser state.
586 */
587
588 void
pmclog_close(void * cookie)589 pmclog_close(void *cookie)
590 {
591 struct pmclog_parse_state *ps;
592
593 ps = (struct pmclog_parse_state *) cookie;
594
595 if (ps->ps_buffer)
596 free(ps->ps_buffer);
597
598 free(ps);
599 }
600