pmclog.c revision 147708
1147191Sjkoshy/*- 2147191Sjkoshy * Copyright (c) 2005 Joseph Koshy 3147191Sjkoshy * All rights reserved. 4147191Sjkoshy * 5147191Sjkoshy * Redistribution and use in source and binary forms, with or without 6147191Sjkoshy * modification, are permitted provided that the following conditions 7147191Sjkoshy * are met: 8147191Sjkoshy * 1. Redistributions of source code must retain the above copyright 9147191Sjkoshy * notice, this list of conditions and the following disclaimer. 10147191Sjkoshy * 2. Redistributions in binary form must reproduce the above copyright 11147191Sjkoshy * notice, this list of conditions and the following disclaimer in the 12147191Sjkoshy * documentation and/or other materials provided with the distribution. 13147191Sjkoshy * 14147191Sjkoshy * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15147191Sjkoshy * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16147191Sjkoshy * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17147191Sjkoshy * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18147191Sjkoshy * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19147191Sjkoshy * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20147191Sjkoshy * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21147191Sjkoshy * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22147191Sjkoshy * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23147191Sjkoshy * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24147191Sjkoshy * SUCH DAMAGE. 25147191Sjkoshy */ 26147191Sjkoshy 27147191Sjkoshy#include <sys/cdefs.h> 28147191Sjkoshy__FBSDID("$FreeBSD: head/lib/libpmc/pmclog.c 147708 2005-06-30 19:01:26Z jkoshy $"); 29147191Sjkoshy 30147191Sjkoshy#include <sys/param.h> 31147191Sjkoshy#include <sys/pmc.h> 32147191Sjkoshy#include <sys/pmclog.h> 33147191Sjkoshy 34147191Sjkoshy#include <assert.h> 35147191Sjkoshy#include <errno.h> 36147191Sjkoshy#include <pmc.h> 37147191Sjkoshy#include <pmclog.h> 38147191Sjkoshy#include <stddef.h> 39147191Sjkoshy#include <stdlib.h> 40147191Sjkoshy#include <string.h> 41147191Sjkoshy#include <strings.h> 42147191Sjkoshy#include <unistd.h> 43147191Sjkoshy 44147191Sjkoshy#include <machine/pmc_mdep.h> 45147191Sjkoshy 46147191Sjkoshy#define PMCLOG_BUFFER_SIZE 4096 47147191Sjkoshy 48147191Sjkoshy/* 49147191Sjkoshy * API NOTES 50147191Sjkoshy * 51147191Sjkoshy * The pmclog(3) API is oriented towards parsing an event stream in 52147191Sjkoshy * "realtime", i.e., from an data source that may or may not preserve 53147191Sjkoshy * record boundaries -- for example when the data source is elsewhere 54147191Sjkoshy * on a network. The API allows data to be fed into the parser zero 55147191Sjkoshy * or more bytes at a time. 56147191Sjkoshy * 57147191Sjkoshy * The state for a log file parser is maintained in a 'struct 58147191Sjkoshy * pmclog_parse_state'. Parser invocations are done by calling 59147191Sjkoshy * 'pmclog_read()'; this function will inform the caller when a 60147191Sjkoshy * complete event is parsed. 61147191Sjkoshy * 62147191Sjkoshy * The parser first assembles a complete log file event in an internal 63147191Sjkoshy * work area (see "ps_saved" below). Once a complete log file event 64147191Sjkoshy * is read, the parser then parses it and converts it to an event 65147191Sjkoshy * descriptor usable by the client. We could possibly avoid this two 66147191Sjkoshy * step process by directly parsing the input log to set fields in the 67147191Sjkoshy * event record. However the parser's state machine would get 68147191Sjkoshy * insanely complicated, and this code is unlikely to be used in 69147191Sjkoshy * performance critical paths. 70147191Sjkoshy */ 71147191Sjkoshy 72147191Sjkoshyenum pmclog_parser_state { 73147191Sjkoshy PL_STATE_NEW_RECORD, /* in-between records */ 74147191Sjkoshy PL_STATE_EXPECTING_HEADER, /* header being read */ 75147191Sjkoshy PL_STATE_PARTIAL_RECORD, /* header present but not the record */ 76147191Sjkoshy PL_STATE_ERROR /* parsing error encountered */ 77147191Sjkoshy}; 78147191Sjkoshy 79147191Sjkoshystruct pmclog_parse_state { 80147191Sjkoshy enum pmclog_parser_state ps_state; 81147191Sjkoshy enum pmc_cputype ps_arch; /* log file architecture */ 82147191Sjkoshy uint32_t ps_version; /* hwpmc version */ 83147191Sjkoshy int ps_initialized; /* whether initialized */ 84147191Sjkoshy int ps_count; /* count of records processed */ 85147191Sjkoshy off_t ps_offset; /* stream byte offset */ 86147191Sjkoshy union pmclog_entry ps_saved; /* saved partial log entry */ 87147191Sjkoshy int ps_svcount; /* #bytes saved */ 88147191Sjkoshy int ps_fd; /* active fd or -1 */ 89147191Sjkoshy char *ps_buffer; /* scratch buffer if fd != -1 */ 90147191Sjkoshy char *ps_data; /* current parse pointer */ 91147191Sjkoshy size_t ps_len; /* length of buffered data */ 92147191Sjkoshy}; 93147191Sjkoshy 94147191Sjkoshy#define PMCLOG_HEADER_FROM_SAVED_STATE(PS) \ 95147191Sjkoshy (* ((uint32_t *) &(PS)->ps_saved)) 96147191Sjkoshy 97147191Sjkoshy#define PMCLOG_INITIALIZE_READER(LE,A) LE = (uint32_t *) &(A) 98147191Sjkoshy#define PMCLOG_READ32(LE,V) do { \ 99147191Sjkoshy (V) = *(LE)++; \ 100147191Sjkoshy } while (0) 101147191Sjkoshy#define PMCLOG_READ64(LE,V) do { \ 102147191Sjkoshy uint64_t _v; \ 103147191Sjkoshy _v = (uint64_t) *(LE)++; \ 104147191Sjkoshy _v |= ((uint64_t) *(LE)++) << 32; \ 105147191Sjkoshy (V) = _v; \ 106147191Sjkoshy } while (0) 107147191Sjkoshy 108147191Sjkoshy#define PMCLOG_READSTRING(LE,DST,LEN) strlcpy((DST), (char *) (LE), (LEN)) 109147191Sjkoshy 110147191Sjkoshy/* 111147191Sjkoshy * Assemble a log record from '*len' octets starting from address '*data'. 112147191Sjkoshy * Update 'data' and 'len' to reflect the number of bytes consumed. 113147191Sjkoshy * 114147191Sjkoshy * '*data' is potentially an unaligned address and '*len' octets may 115147191Sjkoshy * not be enough to complete a event record. 116147191Sjkoshy */ 117147191Sjkoshy 118147191Sjkoshystatic enum pmclog_parser_state 119147191Sjkoshypmclog_get_record(struct pmclog_parse_state *ps, char **data, ssize_t *len) 120147191Sjkoshy{ 121147191Sjkoshy int avail, copylen, recordsize, used; 122147191Sjkoshy uint32_t h; 123147191Sjkoshy const int HEADERSIZE = sizeof(uint32_t); 124147191Sjkoshy char *src, *dst; 125147191Sjkoshy 126147191Sjkoshy if ((avail = *len) <= 0) 127147191Sjkoshy return (ps->ps_state = PL_STATE_ERROR); 128147191Sjkoshy 129147191Sjkoshy src = *data; 130147191Sjkoshy h = used = 0; 131147191Sjkoshy 132147191Sjkoshy if (ps->ps_state == PL_STATE_NEW_RECORD) 133147191Sjkoshy ps->ps_svcount = 0; 134147191Sjkoshy 135147191Sjkoshy dst = (char *) &ps->ps_saved + ps->ps_svcount; 136147191Sjkoshy 137147191Sjkoshy switch (ps->ps_state) { 138147191Sjkoshy case PL_STATE_NEW_RECORD: 139147191Sjkoshy 140147191Sjkoshy /* 141147191Sjkoshy * Transitions: 142147191Sjkoshy * 143147191Sjkoshy * Case A: avail < headersize 144147191Sjkoshy * -> 'expecting header' 145147191Sjkoshy * 146147191Sjkoshy * Case B: avail >= headersize 147147191Sjkoshy * B.1: avail < recordsize 148147191Sjkoshy * -> 'partial record' 149147191Sjkoshy * B.2: avail >= recordsize 150147191Sjkoshy * -> 'new record' 151147191Sjkoshy */ 152147191Sjkoshy 153147191Sjkoshy copylen = avail < HEADERSIZE ? avail : HEADERSIZE; 154147191Sjkoshy bcopy(src, dst, copylen); 155147191Sjkoshy ps->ps_svcount = used = copylen; 156147191Sjkoshy 157147191Sjkoshy if (copylen < HEADERSIZE) { 158147191Sjkoshy ps->ps_state = PL_STATE_EXPECTING_HEADER; 159147191Sjkoshy goto done; 160147191Sjkoshy } 161147191Sjkoshy 162147191Sjkoshy src += copylen; 163147191Sjkoshy dst += copylen; 164147191Sjkoshy 165147191Sjkoshy h = PMCLOG_HEADER_FROM_SAVED_STATE(ps); 166147191Sjkoshy recordsize = PMCLOG_HEADER_TO_LENGTH(h); 167147191Sjkoshy 168147191Sjkoshy if (recordsize <= 0) 169147191Sjkoshy goto error; 170147191Sjkoshy 171147191Sjkoshy if (recordsize <= avail) { /* full record available */ 172147191Sjkoshy bcopy(src, dst, recordsize - copylen); 173147191Sjkoshy ps->ps_svcount = used = recordsize; 174147191Sjkoshy goto done; 175147191Sjkoshy } 176147191Sjkoshy 177147191Sjkoshy /* header + a partial record is available */ 178147191Sjkoshy bcopy(src, dst, avail - copylen); 179147191Sjkoshy ps->ps_svcount = used = avail; 180147191Sjkoshy ps->ps_state = PL_STATE_PARTIAL_RECORD; 181147191Sjkoshy 182147191Sjkoshy break; 183147191Sjkoshy 184147191Sjkoshy case PL_STATE_EXPECTING_HEADER: 185147191Sjkoshy 186147191Sjkoshy /* 187147191Sjkoshy * Transitions: 188147191Sjkoshy * 189147191Sjkoshy * Case C: avail+saved < headersize 190147191Sjkoshy * -> 'expecting header' 191147191Sjkoshy * 192147191Sjkoshy * Case D: avail+saved >= headersize 193147191Sjkoshy * D.1: avail+saved < recordsize 194147191Sjkoshy * -> 'partial record' 195147191Sjkoshy * D.2: avail+saved >= recordsize 196147191Sjkoshy * -> 'new record' 197147191Sjkoshy * (see PARTIAL_RECORD handling below) 198147191Sjkoshy */ 199147191Sjkoshy 200147191Sjkoshy if (avail + ps->ps_svcount < HEADERSIZE) { 201147191Sjkoshy bcopy(src, dst, avail); 202147191Sjkoshy ps->ps_svcount += avail; 203147191Sjkoshy used = avail; 204147191Sjkoshy break; 205147191Sjkoshy } 206147191Sjkoshy 207147191Sjkoshy used = copylen = HEADERSIZE - ps->ps_svcount; 208147191Sjkoshy bcopy(src, dst, copylen); 209147191Sjkoshy src += copylen; 210147191Sjkoshy dst += copylen; 211147191Sjkoshy avail -= copylen; 212147191Sjkoshy ps->ps_svcount += copylen; 213147191Sjkoshy 214147191Sjkoshy /*FALLTHROUGH*/ 215147191Sjkoshy 216147191Sjkoshy case PL_STATE_PARTIAL_RECORD: 217147191Sjkoshy 218147191Sjkoshy /* 219147191Sjkoshy * Transitions: 220147191Sjkoshy * 221147191Sjkoshy * Case E: avail+saved < recordsize 222147191Sjkoshy * -> 'partial record' 223147191Sjkoshy * 224147191Sjkoshy * Case F: avail+saved >= recordsize 225147191Sjkoshy * -> 'new record' 226147191Sjkoshy */ 227147191Sjkoshy 228147191Sjkoshy h = PMCLOG_HEADER_FROM_SAVED_STATE(ps); 229147191Sjkoshy recordsize = PMCLOG_HEADER_TO_LENGTH(h); 230147191Sjkoshy 231147191Sjkoshy if (recordsize <= 0) 232147191Sjkoshy goto error; 233147191Sjkoshy 234147191Sjkoshy if (avail + ps->ps_svcount < recordsize) { 235147191Sjkoshy copylen = avail; 236147191Sjkoshy ps->ps_state = PL_STATE_PARTIAL_RECORD; 237147191Sjkoshy } else { 238147191Sjkoshy copylen = recordsize - ps->ps_svcount; 239147191Sjkoshy ps->ps_state = PL_STATE_NEW_RECORD; 240147191Sjkoshy } 241147191Sjkoshy 242147191Sjkoshy bcopy(src, dst, copylen); 243147191Sjkoshy ps->ps_svcount += copylen; 244147191Sjkoshy used += copylen; 245147191Sjkoshy break; 246147191Sjkoshy 247147191Sjkoshy default: 248147191Sjkoshy goto error; 249147191Sjkoshy } 250147191Sjkoshy 251147191Sjkoshy done: 252147191Sjkoshy *data += used; 253147191Sjkoshy *len -= used; 254147191Sjkoshy return ps->ps_state; 255147191Sjkoshy 256147191Sjkoshy error: 257147191Sjkoshy ps->ps_state = PL_STATE_ERROR; 258147191Sjkoshy return ps->ps_state; 259147191Sjkoshy} 260147191Sjkoshy 261147191Sjkoshy/* 262147191Sjkoshy * Get an event from the stream pointed to by '*data'. '*len' 263147191Sjkoshy * indicates the number of bytes available to parse. Arguments 264147191Sjkoshy * '*data' and '*len' are updated to indicate the number of bytes 265147191Sjkoshy * consumed. 266147191Sjkoshy */ 267147191Sjkoshy 268147191Sjkoshystatic int 269147191Sjkoshypmclog_get_event(void *cookie, char **data, ssize_t *len, 270147191Sjkoshy struct pmclog_ev *ev) 271147191Sjkoshy{ 272147191Sjkoshy int evlen, pathlen; 273147191Sjkoshy uint32_t h, *le; 274147191Sjkoshy enum pmclog_parser_state e; 275147191Sjkoshy struct pmclog_parse_state *ps; 276147191Sjkoshy 277147191Sjkoshy ps = (struct pmclog_parse_state *) cookie; 278147191Sjkoshy 279147191Sjkoshy assert(ps->ps_state != PL_STATE_ERROR); 280147191Sjkoshy 281147191Sjkoshy if ((e = pmclog_get_record(ps,data,len)) == PL_STATE_ERROR) { 282147191Sjkoshy ev->pl_state = PMCLOG_ERROR; 283147191Sjkoshy return -1; 284147191Sjkoshy } 285147191Sjkoshy 286147191Sjkoshy if (e != PL_STATE_NEW_RECORD) { 287147191Sjkoshy ev->pl_state = PMCLOG_REQUIRE_DATA; 288147191Sjkoshy return -1; 289147191Sjkoshy } 290147191Sjkoshy 291147191Sjkoshy PMCLOG_INITIALIZE_READER(le, ps->ps_saved); 292147191Sjkoshy 293147191Sjkoshy PMCLOG_READ32(le,h); 294147191Sjkoshy 295147191Sjkoshy if (!PMCLOG_HEADER_CHECK_MAGIC(h)) { 296147191Sjkoshy ps->ps_state = PL_STATE_ERROR; 297147191Sjkoshy ev->pl_state = PMCLOG_ERROR; 298147191Sjkoshy return -1; 299147191Sjkoshy } 300147191Sjkoshy 301147191Sjkoshy /* copy out the time stamp */ 302147191Sjkoshy PMCLOG_READ32(le,ev->pl_ts.tv_sec); 303147191Sjkoshy PMCLOG_READ32(le,ev->pl_ts.tv_nsec); 304147191Sjkoshy 305147191Sjkoshy evlen = PMCLOG_HEADER_TO_LENGTH(h); 306147191Sjkoshy 307147191Sjkoshy#define PMCLOG_GET_PATHLEN(P,E,TYPE) do { \ 308147191Sjkoshy (P) = (E) - offsetof(struct TYPE, pl_pathname); \ 309147191Sjkoshy if ((P) > PATH_MAX || (P) < 0) \ 310147191Sjkoshy goto error; \ 311147191Sjkoshy } while (0) 312147191Sjkoshy 313147191Sjkoshy switch (ev->pl_type = PMCLOG_HEADER_TO_TYPE(h)) { 314147191Sjkoshy case PMCLOG_TYPE_CLOSELOG: 315147191Sjkoshy case PMCLOG_TYPE_DROPNOTIFY: 316147191Sjkoshy /* nothing to do */ 317147191Sjkoshy break; 318147191Sjkoshy case PMCLOG_TYPE_INITIALIZE: 319147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_i.pl_version); 320147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_i.pl_arch); 321147191Sjkoshy ps->ps_version = ev->pl_u.pl_i.pl_version; 322147191Sjkoshy ps->ps_arch = ev->pl_u.pl_i.pl_arch; 323147191Sjkoshy ps->ps_initialized = 1; 324147191Sjkoshy break; 325147191Sjkoshy case PMCLOG_TYPE_MAPPINGCHANGE: 326147191Sjkoshy PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_mappingchange); 327147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_m.pl_type); 328147191Sjkoshy PMCLOG_READADDR(le,ev->pl_u.pl_m.pl_start); 329147191Sjkoshy PMCLOG_READADDR(le,ev->pl_u.pl_m.pl_end); 330147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_m.pl_pid); 331147191Sjkoshy PMCLOG_READSTRING(le, ev->pl_u.pl_m.pl_pathname, pathlen); 332147191Sjkoshy break; 333147191Sjkoshy case PMCLOG_TYPE_PCSAMPLE: 334147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_s.pl_pid); 335147191Sjkoshy PMCLOG_READADDR(le,ev->pl_u.pl_s.pl_pc); 336147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_s.pl_pmcid); 337147708Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_s.pl_usermode); 338147191Sjkoshy break; 339147191Sjkoshy case PMCLOG_TYPE_PMCALLOCATE: 340147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_a.pl_pmcid); 341147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_a.pl_event); 342147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_a.pl_flags); 343147191Sjkoshy if ((ev->pl_u.pl_a.pl_evname = 344147191Sjkoshy pmc_name_of_event(ev->pl_u.pl_a.pl_event)) == NULL) 345147191Sjkoshy goto error; 346147191Sjkoshy break; 347147191Sjkoshy case PMCLOG_TYPE_PMCATTACH: 348147191Sjkoshy PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_pmcattach); 349147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pmcid); 350147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_t.pl_pid); 351147191Sjkoshy PMCLOG_READSTRING(le,ev->pl_u.pl_t.pl_pathname,pathlen); 352147191Sjkoshy break; 353147191Sjkoshy case PMCLOG_TYPE_PMCDETACH: 354147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pmcid); 355147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_d.pl_pid); 356147191Sjkoshy break; 357147191Sjkoshy case PMCLOG_TYPE_PROCCSW: 358147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pmcid); 359147191Sjkoshy PMCLOG_READ64(le,ev->pl_u.pl_c.pl_value); 360147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_c.pl_pid); 361147191Sjkoshy break; 362147191Sjkoshy case PMCLOG_TYPE_PROCEXEC: 363147191Sjkoshy PMCLOG_GET_PATHLEN(pathlen,evlen,pmclog_procexec); 364147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pid); 365147708Sjkoshy PMCLOG_READADDR(le,ev->pl_u.pl_x.pl_entryaddr); 366147708Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_x.pl_pmcid); 367147191Sjkoshy PMCLOG_READSTRING(le,ev->pl_u.pl_x.pl_pathname,pathlen); 368147191Sjkoshy break; 369147191Sjkoshy case PMCLOG_TYPE_PROCEXIT: 370147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pmcid); 371147191Sjkoshy PMCLOG_READ64(le,ev->pl_u.pl_e.pl_value); 372147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_e.pl_pid); 373147191Sjkoshy break; 374147191Sjkoshy case PMCLOG_TYPE_PROCFORK: 375147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_f.pl_oldpid); 376147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_f.pl_newpid); 377147191Sjkoshy break; 378147191Sjkoshy case PMCLOG_TYPE_SYSEXIT: 379147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_se.pl_pid); 380147191Sjkoshy break; 381147191Sjkoshy case PMCLOG_TYPE_USERDATA: 382147191Sjkoshy PMCLOG_READ32(le,ev->pl_u.pl_u.pl_userdata); 383147191Sjkoshy break; 384147191Sjkoshy default: /* unknown record type */ 385147191Sjkoshy ps->ps_state = PL_STATE_ERROR; 386147191Sjkoshy ev->pl_state = PMCLOG_ERROR; 387147191Sjkoshy return -1; 388147191Sjkoshy } 389147191Sjkoshy 390147191Sjkoshy ev->pl_offset = (ps->ps_offset += evlen); 391147191Sjkoshy ev->pl_count = (ps->ps_count += 1); 392147191Sjkoshy ev->pl_state = PMCLOG_OK; 393147191Sjkoshy return 0; 394147191Sjkoshy 395147191Sjkoshy error: 396147191Sjkoshy ev->pl_state = PMCLOG_ERROR; 397147191Sjkoshy ps->ps_state = PL_STATE_ERROR; 398147191Sjkoshy return -1; 399147191Sjkoshy} 400147191Sjkoshy 401147191Sjkoshy/* 402147191Sjkoshy * Extract and return the next event from the byte stream. 403147191Sjkoshy * 404147191Sjkoshy * Returns 0 and sets the event's state to PMCLOG_OK in case an event 405147191Sjkoshy * was successfully parsed. Otherwise this function returns -1 and 406147191Sjkoshy * sets the event's state to one of PMCLOG_REQUIRE_DATA (if more data 407147191Sjkoshy * is needed) or PMCLOG_EOF (if an EOF was seen) or PMCLOG_ERROR if 408147191Sjkoshy * a parse error was encountered. 409147191Sjkoshy */ 410147191Sjkoshy 411147191Sjkoshyint 412147191Sjkoshypmclog_read(void *cookie, struct pmclog_ev *ev) 413147191Sjkoshy{ 414147191Sjkoshy ssize_t nread; 415147191Sjkoshy struct pmclog_parse_state *ps; 416147191Sjkoshy 417147191Sjkoshy ps = (struct pmclog_parse_state *) cookie; 418147191Sjkoshy 419147191Sjkoshy if (ps->ps_state == PL_STATE_ERROR) { 420147191Sjkoshy ev->pl_state = PMCLOG_ERROR; 421147191Sjkoshy return -1; 422147191Sjkoshy } 423147191Sjkoshy 424147191Sjkoshy /* 425147191Sjkoshy * If there isn't enough data left for a new event try and get 426147191Sjkoshy * more data. 427147191Sjkoshy */ 428147191Sjkoshy if (ps->ps_len == 0) { 429147191Sjkoshy ev->pl_state = PMCLOG_REQUIRE_DATA; 430147191Sjkoshy 431147191Sjkoshy /* 432147191Sjkoshy * If we have a valid file descriptor to read from, attempt 433147191Sjkoshy * to read from that. This read may return with an error, 434147191Sjkoshy * (which may be EAGAIN or other recoverable error), or 435147191Sjkoshy * can return EOF. 436147191Sjkoshy */ 437147191Sjkoshy if (ps->ps_fd != PMCLOG_FD_NONE) { 438147191Sjkoshy nread = read(ps->ps_fd, ps->ps_buffer, 439147191Sjkoshy PMCLOG_BUFFER_SIZE); 440147191Sjkoshy 441147191Sjkoshy if (nread <= 0) { 442147708Sjkoshy if (nread == 0) 443147708Sjkoshy ev->pl_state = PMCLOG_EOF; 444147708Sjkoshy else if (errno != EAGAIN) /* not restartable */ 445147708Sjkoshy ev->pl_state = PMCLOG_ERROR; 446147191Sjkoshy return -1; 447147191Sjkoshy } 448147191Sjkoshy 449147191Sjkoshy ps->ps_len = nread; 450147191Sjkoshy ps->ps_data = ps->ps_buffer; 451147191Sjkoshy } else 452147191Sjkoshy return -1; 453147191Sjkoshy } 454147191Sjkoshy 455147191Sjkoshy assert(ps->ps_len > 0); 456147191Sjkoshy 457147191Sjkoshy /* 458147191Sjkoshy * Retrieve one event from the byte stream. 459147191Sjkoshy */ 460147191Sjkoshy return pmclog_get_event(ps, &ps->ps_data, &ps->ps_len, ev); 461147191Sjkoshy} 462147191Sjkoshy 463147191Sjkoshy/* 464147191Sjkoshy * Feed data to a memory based parser. 465147191Sjkoshy * 466147191Sjkoshy * The memory area pointed to by 'data' needs to be valid till the 467147191Sjkoshy * next error return from pmclog_next_event(). 468147191Sjkoshy */ 469147191Sjkoshy 470147191Sjkoshyint 471147191Sjkoshypmclog_feed(void *cookie, char *data, int len) 472147191Sjkoshy{ 473147191Sjkoshy struct pmclog_parse_state *ps; 474147191Sjkoshy 475147191Sjkoshy ps = (struct pmclog_parse_state *) cookie; 476147191Sjkoshy 477147191Sjkoshy if (len < 0 || /* invalid length */ 478147191Sjkoshy ps->ps_buffer || /* called for a file parser */ 479147191Sjkoshy ps->ps_len != 0) /* unnecessary call */ 480147191Sjkoshy return -1; 481147191Sjkoshy 482147191Sjkoshy ps->ps_data = data; 483147191Sjkoshy ps->ps_len = len; 484147191Sjkoshy 485147191Sjkoshy return 0; 486147191Sjkoshy} 487147191Sjkoshy 488147191Sjkoshy/* 489147191Sjkoshy * Allocate and initialize parser state. 490147191Sjkoshy */ 491147191Sjkoshy 492147191Sjkoshyvoid * 493147191Sjkoshypmclog_open(int fd) 494147191Sjkoshy{ 495147191Sjkoshy struct pmclog_parse_state *ps; 496147191Sjkoshy 497147191Sjkoshy if ((ps = (struct pmclog_parse_state *) malloc(sizeof(*ps))) == NULL) 498147191Sjkoshy return NULL; 499147191Sjkoshy 500147191Sjkoshy ps->ps_state = PL_STATE_NEW_RECORD; 501147191Sjkoshy ps->ps_arch = -1; 502147191Sjkoshy ps->ps_initialized = 0; 503147191Sjkoshy ps->ps_count = 0; 504147191Sjkoshy ps->ps_offset = (off_t) 0; 505147191Sjkoshy bzero(&ps->ps_saved, sizeof(ps->ps_saved)); 506147191Sjkoshy ps->ps_svcount = 0; 507147191Sjkoshy ps->ps_fd = fd; 508147191Sjkoshy ps->ps_data = NULL; 509147191Sjkoshy ps->ps_buffer = NULL; 510147191Sjkoshy ps->ps_len = 0; 511147191Sjkoshy 512147191Sjkoshy /* allocate space for a work area */ 513147191Sjkoshy if (ps->ps_fd != PMCLOG_FD_NONE) { 514147191Sjkoshy if ((ps->ps_buffer = malloc(PMCLOG_BUFFER_SIZE)) == NULL) 515147191Sjkoshy return NULL; 516147191Sjkoshy } 517147191Sjkoshy 518147191Sjkoshy return ps; 519147191Sjkoshy} 520147191Sjkoshy 521147191Sjkoshy 522147191Sjkoshy/* 523147191Sjkoshy * Free up parser state. 524147191Sjkoshy */ 525147191Sjkoshy 526147191Sjkoshyvoid 527147191Sjkoshypmclog_close(void *cookie) 528147191Sjkoshy{ 529147191Sjkoshy struct pmclog_parse_state *ps; 530147191Sjkoshy 531147191Sjkoshy ps = (struct pmclog_parse_state *) cookie; 532147191Sjkoshy 533147191Sjkoshy if (ps->ps_buffer) 534147191Sjkoshy free(ps->ps_buffer); 535147191Sjkoshy 536147191Sjkoshy free(ps); 537147191Sjkoshy} 538