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