lib/libpmc/pmclog.c

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