1 /* 2 * Copyright (c) 2009, 2010 Aggelos Economopoulos. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 3. Neither the name of The DragonFly Project nor the names of its 15 * contributors may be used to endorse or promote products derived 16 * from this software without specific, prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 22 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #ifndef EVTR_H 33 #define EVTR_H 34 35 #include <stdint.h> 36 #include <stdio.h> 37 #include <sys/queue.h> 38 /* XXX: remove */ 39 #include <sys/tree.h> 40 41 enum { 42 EVTR_TYPE_PAD = 0x0, 43 EVTR_TYPE_PROBE = 0x1, 44 EVTR_TYPE_STR = 0x2, 45 EVTR_TYPE_FMT = 0x3, 46 EVTR_TYPE_SYSINFO = 0x4, 47 EVTR_TYPE_CPUINFO = 0x5, 48 EVTR_TYPE_STMT = 0x6, 49 }; 50 51 struct hashtab; 52 typedef struct evtr_variable_value { 53 enum evtr_value_type { 54 EVTR_VAL_NIL, 55 EVTR_VAL_INT, 56 EVTR_VAL_STR, 57 EVTR_VAL_HASH, 58 EVTR_VAL_CTOR, 59 } type; 60 union { 61 uintmax_t num; 62 const char *str; 63 struct hashtab *hashtab; 64 const struct symtab *symtab; 65 struct { 66 const char *name; 67 TAILQ_HEAD(, evtr_variable_value) args; 68 } ctor; 69 }; 70 TAILQ_ENTRY(evtr_variable_value) link; 71 } *evtr_variable_value_t; 72 73 typedef struct evtr_variable { 74 const char *name; 75 struct evtr_variable_value val; 76 } *evtr_var_t; 77 78 struct evtr_thread { 79 RB_ENTRY(evtr_thread) rb_node; 80 void *id; 81 const char *comm; 82 /* available for the user of the library, NULL if not set */ 83 void *userdata; 84 }; 85 86 /* 87 * This structure is used for interchange of data with 88 * the user of the library 89 */ 90 typedef struct evtr_event { 91 uint8_t type; /* EVTR_TYPE_* */ 92 uint64_t ts; /* timestamp. Must be nondecreasing */ 93 union { 94 uint16_t ncpus; /* EVTR_TYPE_SYSINFO */ 95 struct evtr_cpuinfo { /* EVTR_TYPE_CPUINFO */ 96 double freq; 97 } cpuinfo; 98 struct evtr_stmt { 99 const struct evtr_variable *var; 100 enum evtr_op { 101 EVTR_OP_SET, 102 } op; 103 struct evtr_variable_value *val; 104 } stmt; 105 }; 106 /* 107 * Pointer to filename. NULL if n/a. 108 * For an event returned by the library, 109 * it is a pointer to storage allocated 110 * by the library that will be around 111 * until the call to evtr_close. 112 */ 113 const char *file; 114 /* Same as above */ 115 const char *func; 116 /* line number. 0 if n/a */ 117 uint16_t line; 118 /* 119 * Format string, also used to identify 120 * the event. Ownership rules are the same 121 * as for file. 122 */ 123 const char *fmt; 124 /* 125 * Data corresponding to the format string. 126 * For an event returned by the library, 127 * it is a pointer to an internal buffer 128 * that becomes invalid when the next record 129 * is returned. If the user wants to keep this 130 * data around, they must copy it. 131 */ 132 const void *fmtdata; 133 /* Length of fmtdata */ 134 int fmtdatalen; 135 /* Cpu on which the event occured */ 136 uint8_t cpu; 137 /* 138 * Thread, which generated the event (if applicable). The 139 * storage pointed to belongs to the library and may (even 140 * though it's highly unlikely) point to a different thread 141 * in the future. The user needs to copy it if they want 142 * this data. 143 */ 144 struct evtr_thread *td; 145 } *evtr_event_t; 146 147 /* 148 * Specifies which conditions to filter query results 149 * with. It is modified by the library and should 150 * not be touched after initialization. 151 */ 152 typedef struct evtr_filter { 153 int flags; /* must be initialized to 0 */ 154 /* 155 * Which cpu we are interested in. -1 means 156 * any cpu. XXX: use mask? (note we could just 157 * do that internally) 158 */ 159 int cpu; 160 /* what event type we're interested in */ 161 int ev_type; 162 /* 163 * If the user sets fmt, only events with a format 164 * string identical to the one specified will be 165 * returned. This field is modified by the library. 166 */ 167 union { 168 const char *fmt; 169 int fmtid; 170 const char *var; 171 }; 172 } *evtr_filter_t; 173 174 struct evtr_query; 175 struct evtr; 176 typedef struct evtr *evtr_t; 177 typedef struct evtr_query *evtr_query_t; 178 179 evtr_t evtr_open_read(FILE *); 180 evtr_t evtr_open_write(FILE *); 181 void evtr_close(evtr_t); 182 int evtr_dump_event(evtr_t, evtr_event_t); 183 int evtr_error(evtr_t); 184 const char * evtr_errmsg(evtr_t); 185 int evtr_query_error(evtr_query_t); 186 const char * evtr_query_errmsg(evtr_query_t); 187 void evtr_event_data(evtr_event_t, char *, size_t); 188 struct evtr_query * evtr_query_init(evtr_t, evtr_filter_t, int); 189 void evtr_query_destroy(struct evtr_query *); 190 int evtr_query_next(struct evtr_query *, evtr_event_t); 191 int evtr_last_event(evtr_t, evtr_event_t); 192 int evtr_rewind(evtr_t); 193 194 int evtr_ncpus(evtr_t); 195 int evtr_cpufreqs(evtr_t, double *); 196 void evtr_set_debug(const char *); 197 198 199 #endif /* EVTR_H */ 200