lib/libpmc/pmclog.c

   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/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 #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_SKIP32(LE)               (LE)++
  86 #define PMCLOG_READ32(LE,V)             do {                            \
  87                 (V)  = *(LE)++;                                         \
  88         } while (0)
  89 #define PMCLOG_READ64(LE,V)             do {                            \
  90                 uint64_t _v;                                            \
  91                 _v  = (uint64_t) *(LE)++;                               \
  92                 _v |= ((uint64_t) *(LE)++) << 32;                       \
  93                 (V) = _v;                                               \
  94         } while (0)
  95
  96 #define PMCLOG_READSTRING(LE,DST,LEN)   strlcpy((DST), (char *) (LE), (LEN))
  97
  98 /*
  99  * Assemble a log record from '*len' octets starting from address '*data'.
 100  * Update 'data' and 'len' to reflect the number of bytes consumed.
 101  *
 102  * '*data' is potentially an unaligned address and '*len' octets may
 103  * not be enough to complete a event record.
 104  */
 105
 106 static enum pmclog_parser_state
 107 pmclog_get_record(struct pmclog_parse_state *ps, char **data, ssize_t *len)
 108 {
 109         int avail, copylen, recordsize, used;
 110         uint32_t h;
 111         const int HEADERSIZE = sizeof(uint32_t);
 112         char *src, *dst;
 113
 114         if ((avail = *len) <= 0)
 115                 return (ps->ps_state = PL_STATE_ERROR);
 116
 117         src = *data;
 118         used = 0;
 119
 120         if (ps->ps_state == PL_STATE_NEW_RECORD)
 121                 ps->ps_svcount = 0;
 122
 123         dst = (char *) &ps->ps_saved + ps->ps_svcount;
 124
 125         switch (ps->ps_state) {
 126         case PL_STATE_NEW_RECORD:
 127
 128                 /*
 129                  * Transitions:
 130                  *
 131                  * Case A: avail < headersize
 132                  *      -> 'expecting header'
 133                  *
 134                  * Case B: avail >= headersize
 135                  *    B.1: avail < recordsize
 136                  *         -> 'partial record'
 137                  *    B.2: avail >= recordsize
 138                  *         -> 'new record'
 139                  */
 140
 141                 copylen = avail < HEADERSIZE ? avail : HEADERSIZE;
 142                 bcopy(src, dst, copylen);
 143                 ps->ps_svcount = used = copylen;
 144
 145                 if (copylen < HEADERSIZE) {
 146                         ps->ps_state = PL_STATE_EXPECTING_HEADER;
 147                         goto done;
 148                 }
 149
 150                 src += copylen;
 151                 dst += copylen;
 152
 153                 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
 154                 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
 155
 156                 if (recordsize <= 0)
 157                         goto error;
 158
 159                 if (recordsize <= avail) { /* full record available */
 160                         bcopy(src, dst, recordsize - copylen);
 161                         ps->ps_svcount = used = recordsize;
 162                         goto done;
 163                 }
 164
 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;
 169
 170                 break;
 171
 172         case PL_STATE_EXPECTING_HEADER:
 173
 174                 /*
 175                  * Transitions:
 176                  *
 177                  * Case C: avail+saved < headersize
 178                  *      -> 'expecting header'
 179                  *
 180                  * Case D: avail+saved >= headersize
 181                  *    D.1: avail+saved < recordsize
 182                  *      -> 'partial record'
 183                  *    D.2: avail+saved >= recordsize
 184                  *      -> 'new record'
 185                  *    (see PARTIAL_RECORD handling below)
 186                  */
 187
 188                 if (avail + ps->ps_svcount < HEADERSIZE) {
 189                         bcopy(src, dst, avail);
 190                         ps->ps_svcount += avail;
 191                         used = avail;
 192                         break;
 193                 }
 194
 195                 used = copylen = HEADERSIZE - ps->ps_svcount;
 196                 bcopy(src, dst, copylen);
 197                 src += copylen;
 198                 dst += copylen;
 199                 avail -= copylen;
 200                 ps->ps_svcount += copylen;
 201
 202                 /*FALLTHROUGH*/
 203
 204         case PL_STATE_PARTIAL_RECORD:
 205
 206                 /*
 207                  * Transitions:
 208                  *
 209                  * Case E: avail+saved < recordsize
 210                  *      -> 'partial record'
 211                  *
 212                  * Case F: avail+saved >= recordsize
 213                  *      -> 'new record'
 214                  */
 215
 216                 h = PMCLOG_HEADER_FROM_SAVED_STATE(ps);
 217                 recordsize = PMCLOG_HEADER_TO_LENGTH(h);
 218
 219                 if (recordsize <= 0)
 220                         goto error;
 221
 222                 if (avail + ps->ps_svcount < recordsize) {
 223                         copylen = avail;
 224                         ps->ps_state = PL_STATE_PARTIAL_RECORD;
 225                 } else {
 226                         copylen = recordsize - ps->ps_svcount;
 227                         ps->ps_state = PL_STATE_NEW_RECORD;
 228                 }
 229
 230                 bcopy(src, dst, copylen);
 231                 ps->ps_svcount += copylen;
 232                 used += copylen;
 233                 break;
 234
 235         default:
 236                 goto error;
 237         }
 238
 239  done:
 240         *data += used;
 241         *len  -= used;
 242         return ps->ps_state;
 243
 244  error:
 245         ps->ps_state = PL_STATE_ERROR;
 246         return ps->ps_state;
 247 }
 248
 249 /*
 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
 253  * consumed.
 254  */
 255
 256 static int
 257 pmclog_get_event(void *cookie, char **data, ssize_t *len,
 258     struct pmclog_ev *ev)
 259 {
 260         int evlen, pathlen;
 261         uint32_t h, *le, npc;
 262         enum pmclog_parser_state e;
 263         struct pmclog_parse_state *ps;
 264         struct pmclog_header *ph;
 265
 266         ps = (struct pmclog_parse_state *) cookie;
 267
 268         assert(ps->ps_state != PL_STATE_ERROR);
 269
 270         if ((e = pmclog_get_record(ps,data,len)) == PL_STATE_ERROR) {
 271                 ev->pl_state = PMCLOG_ERROR;
 272                 printf("state error\n");
 273                 return -1;
 274         }
 275
 276         if (e != PL_STATE_NEW_RECORD) {
 277                 ev->pl_state = PMCLOG_REQUIRE_DATA;
 278                 return -1;
 279         }
 280
 281         PMCLOG_INITIALIZE_READER(le, ps->ps_saved);
 282         ev->pl_data = le;
 283         ph = (struct pmclog_header *)(uintptr_t)le;
 284
 285         h = ph->pl_header;
 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;
 290                 return -1;
 291         }
 292
 293         /* copy out the time stamp */
 294         ev->pl_ts.tv_sec = ph->pl_tsc;
 295         le += sizeof(*ph)/4;
 296
 297         evlen = PMCLOG_HEADER_TO_LENGTH(h);
 298
 299 #define PMCLOG_GET_PATHLEN(P,E,TYPE) do {                               \
 300                 (P) = (E) - offsetof(struct TYPE, pl_pathname);         \
 301                 if ((P) > PATH_MAX || (P) < 0)                          \
 302                         goto error;                                     \
 303         } while (0)
 304
 305 #define PMCLOG_GET_CALLCHAIN_SIZE(SZ,E) do {                            \
 306                 (SZ) = ((E) - offsetof(struct pmclog_callchain, pl_pc)) \
 307                         / sizeof(uintfptr_t);                           \
 308         } while (0);
 309
 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;
 321                 break;
 322         case PMCLOG_TYPE_CLOSELOG:
 323                 ev->pl_state = PMCLOG_EOF;
 324                 return (-1);
 325         case PMCLOG_TYPE_DROPNOTIFY:
 326                 /* nothing to do */
 327                 break;
 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;
 340                 break;
 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);
 344                 PMCLOG_SKIP32(le);
 345                 PMCLOG_READADDR(le,ev->pl_u.pl_mi.pl_start);
 346                 PMCLOG_READSTRING(le, ev->pl_u.pl_mi.pl_pathname, pathlen);
 347                 break;
 348         case PMCLOG_TYPE_MAP_OUT:
 349                 PMCLOG_READ32(le,ev->pl_u.pl_mo.pl_pid);
 350                 PMCLOG_SKIP32(le);
 351                 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_start);
 352                 PMCLOG_READADDR(le,ev->pl_u.pl_mo.pl_end);
 353                 break;
 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);
 358                 PMCLOG_SKIP32(le);
 359                 PMCLOG_READ64(le,ev->pl_u.pl_a.pl_rate);
 360
 361                 /*
 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.
 367                  *
 368                  * XXX: Ideally we'd have user flags to give us that context.
 369                  */
 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,
 377                                 ps->ps_arch);
 378                 else
 379                         ev->pl_u.pl_a.pl_evname = NULL;
 380                 if (ev->pl_u.pl_a.pl_evname == NULL) {
 381                         printf("unknown event\n");
 382                         goto error;
 383                 }
 384                 break;
 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);
 389                 PMCLOG_SKIP32(le);
 390                 PMCLOG_READSTRING(le,ev->pl_u.pl_ad.pl_evname,PMC_NAME_MAX);
 391                 break;
 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);
 397                 break;
 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);
 401                 break;
 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);
 407                 break;
 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);
 415                 break;
 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);
 420                 break;
 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);
 424                 break;
 425         case PMCLOG_TYPE_SYSEXIT:
 426                 PMCLOG_READ32(le,ev->pl_u.pl_se.pl_pid);
 427                 break;
 428         case PMCLOG_TYPE_USERDATA:
 429                 PMCLOG_READ32(le,ev->pl_u.pl_u.pl_userdata);
 430                 break;
 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);
 435                 PMCLOG_SKIP32(le);
 436                 memcpy(ev->pl_u.pl_tc.pl_tdname, le, MAXCOMLEN+1);
 437                 break;
 438         case PMCLOG_TYPE_THR_EXIT:
 439                 PMCLOG_READ32(le,ev->pl_u.pl_te.pl_tid);
 440                 break;
 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);
 445                 break;
 446         default:        /* unknown record type */
 447                 ps->ps_state = PL_STATE_ERROR;
 448                 ev->pl_state = PMCLOG_ERROR;
 449                 return (-1);
 450         }
 451
 452         ev->pl_offset = (ps->ps_offset += evlen);
 453         ev->pl_count  = (ps->ps_count += 1);
 454         ev->pl_len = evlen;
 455         ev->pl_state = PMCLOG_OK;
 456         return 0;
 457
 458  error:
 459         ev->pl_state = PMCLOG_ERROR;
 460         ps->ps_state = PL_STATE_ERROR;
 461         return -1;
 462 }
 463
 464 /*
 465  * Extract and return the next event from the byte stream.
 466  *
 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.
 472  */
 473
 474 int
 475 pmclog_read(void *cookie, struct pmclog_ev *ev)
 476 {
 477         int retval;
 478         ssize_t nread;
 479         struct pmclog_parse_state *ps;
 480
 481         ps = (struct pmclog_parse_state *) cookie;
 482
 483         if (ps->ps_state == PL_STATE_ERROR) {
 484                 ev->pl_state = PMCLOG_ERROR;
 485                 return -1;
 486         }
 487
 488         /*
 489          * If there isn't enough data left for a new event try and get
 490          * more data.
 491          */
 492         if (ps->ps_len == 0) {
 493                 ev->pl_state = PMCLOG_REQUIRE_DATA;
 494
 495                 /*
 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
 499                  * can return EOF.
 500                  */
 501                 if (ps->ps_fd != PMCLOG_FD_NONE) {
 502                 refill:
 503                         nread = read(ps->ps_fd, ps->ps_buffer,
 504                             PMCLOG_BUFFER_SIZE);
 505
 506                         if (nread <= 0) {
 507                                 if (nread == 0)
 508                                         ev->pl_state = PMCLOG_EOF;
 509                                 else if (errno != EAGAIN) /* not restartable */
 510                                         ev->pl_state = PMCLOG_ERROR;
 511                                 return -1;
 512                         }
 513
 514                         ps->ps_len = nread;
 515                         ps->ps_data = ps->ps_buffer;
 516                 } else {
 517                         return -1;
 518                 }
 519         }
 520
 521         assert(ps->ps_len > 0);
 522
 523
 524          /* Retrieve one event from the byte stream. */
 525         retval = pmclog_get_event(ps, &ps->ps_data, &ps->ps_len, ev);
 526         /*
 527          * If we need more data and we have a configured fd, try read
 528          * from it.
 529          */
 530         if (retval < 0 && ev->pl_state == PMCLOG_REQUIRE_DATA &&
 531             ps->ps_fd != -1) {
 532                 assert(ps->ps_len == 0);
 533                 goto refill;
 534         }
 535
 536         return retval;
 537 }
 538
 539 /*
 540  * Feed data to a memory based parser.
 541  *
 542  * The memory area pointed to by 'data' needs to be valid till the
 543  * next error return from pmclog_next_event().
 544  */
 545
 546 int
 547 pmclog_feed(void *cookie, char *data, int len)
 548 {
 549         struct pmclog_parse_state *ps;
 550
 551         ps = (struct pmclog_parse_state *) cookie;
 552
 553         if (len < 0 ||          /* invalid length */
 554             ps->ps_buffer ||    /* called for a file parser */
 555             ps->ps_len != 0)    /* unnecessary call */
 556                 return -1;
 557
 558         ps->ps_data = data;
 559         ps->ps_len  = len;
 560
 561         return 0;
 562 }
 563
 564 /*
 565  * Allocate and initialize parser state.
 566  */
 567
 568 void *
 569 pmclog_open(int fd)
 570 {
 571         struct pmclog_parse_state *ps;
 572
 573         if ((ps = (struct pmclog_parse_state *) malloc(sizeof(*ps))) == NULL)
 574                 return NULL;
 575
 576         ps->ps_state = PL_STATE_NEW_RECORD;
 577         ps->ps_arch = -1;
 578         ps->ps_initialized = 0;
 579         ps->ps_count = 0;
 580         ps->ps_offset = (off_t) 0;
 581         bzero(&ps->ps_saved, sizeof(ps->ps_saved));
 582         ps->ps_cpuid = NULL;
 583         ps->ps_svcount = 0;
 584         ps->ps_fd    = fd;
 585         ps->ps_data  = NULL;
 586         ps->ps_buffer = NULL;
 587         ps->ps_len   = 0;
 588
 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) {
 592                         free(ps);
 593                         return NULL;
 594                 }
 595         }
 596
 597         return ps;
 598 }
 599
 600
 601 /*
 602  * Free up parser state.
 603  */
 604
 605 void
 606 pmclog_close(void *cookie)
 607 {
 608         struct pmclog_parse_state *ps;
 609
 610         ps = (struct pmclog_parse_state *) cookie;
 611
 612         if (ps->ps_buffer)
 613                 free(ps->ps_buffer);
 614
 615         free(ps);
 616 }