Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 256 lines (212 sloc) 6.044 kb
68396ea @rmustacc Initial commit of d32e8d0b8d9e0ef7cf7ab2e74548982972789dfc from qemu-kvm
rmustacc authored
1 /*
2 * Simple trace backend
3 *
4 * Copyright IBM, Corp. 2010
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2. See
7 * the COPYING file in the top-level directory.
8 *
9 */
10
11 #include <stdlib.h>
12 #include <stdint.h>
13 #include <stdio.h>
14 #include <time.h>
15 #include "qemu-timer.h"
16 #include "trace.h"
17
18 /** Trace file header event ID */
19 #define HEADER_EVENT_ID (~(uint64_t)0) /* avoids conflicting with TraceEventIDs */
20
21 /** Trace file magic number */
22 #define HEADER_MAGIC 0xf2b177cb0aa429b4ULL
23
24 /** Trace file version number, bump if format changes */
25 #define HEADER_VERSION 0
26
27 /** Trace buffer entry */
28 typedef struct {
29 uint64_t event;
30 uint64_t timestamp_ns;
31 uint64_t x1;
32 uint64_t x2;
33 uint64_t x3;
34 uint64_t x4;
35 uint64_t x5;
36 uint64_t x6;
37 } TraceRecord;
38
39 enum {
40 TRACE_BUF_LEN = 64 * 1024 / sizeof(TraceRecord),
41 };
42
43 static TraceRecord trace_buf[TRACE_BUF_LEN];
44 static unsigned int trace_idx;
45 static FILE *trace_fp;
46 static char *trace_file_name = NULL;
47 static bool trace_file_enabled = false;
48
49 void st_print_trace_file_status(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
50 {
51 stream_printf(stream, "Trace file \"%s\" %s.\n",
52 trace_file_name, trace_file_enabled ? "on" : "off");
53 }
54
55 static bool write_header(FILE *fp)
56 {
57 static const TraceRecord header = {
58 .event = HEADER_EVENT_ID,
59 .timestamp_ns = HEADER_MAGIC,
60 .x1 = HEADER_VERSION,
61 };
62
63 return fwrite(&header, sizeof header, 1, fp) == 1;
64 }
65
66 /**
67 * set_trace_file : To set the name of a trace file.
68 * @file : pointer to the name to be set.
69 * If NULL, set to the default name-<pid> set at config time.
70 */
71 bool st_set_trace_file(const char *file)
72 {
73 st_set_trace_file_enabled(false);
74
75 free(trace_file_name);
76
77 if (!file) {
78 if (asprintf(&trace_file_name, CONFIG_TRACE_FILE, getpid()) < 0) {
79 trace_file_name = NULL;
80 return false;
81 }
82 } else {
83 if (asprintf(&trace_file_name, "%s", file) < 0) {
84 trace_file_name = NULL;
85 return false;
86 }
87 }
88
89 st_set_trace_file_enabled(true);
90 return true;
91 }
92
93 static void flush_trace_file(void)
94 {
95 /* If the trace file is not open yet, open it now */
96 if (!trace_fp) {
97 trace_fp = fopen(trace_file_name, "w");
98 if (!trace_fp) {
99 /* Avoid repeatedly trying to open file on failure */
100 trace_file_enabled = false;
101 return;
102 }
103 write_header(trace_fp);
104 }
105
106 if (trace_fp) {
107 size_t unused; /* for when fwrite(3) is declared warn_unused_result */
108 unused = fwrite(trace_buf, trace_idx * sizeof(trace_buf[0]), 1, trace_fp);
109 }
110 }
111
112 void st_flush_trace_buffer(void)
113 {
114 if (trace_file_enabled) {
115 flush_trace_file();
116 }
117
118 /* Discard written trace records */
119 trace_idx = 0;
120 }
121
122 void st_set_trace_file_enabled(bool enable)
123 {
124 if (enable == trace_file_enabled) {
125 return; /* no change */
126 }
127
128 /* Flush/discard trace buffer */
129 st_flush_trace_buffer();
130
131 /* To disable, close trace file */
132 if (!enable) {
133 fclose(trace_fp);
134 trace_fp = NULL;
135 }
136
137 trace_file_enabled = enable;
138 }
139
140 static void trace(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3,
141 uint64_t x4, uint64_t x5, uint64_t x6)
142 {
143 TraceRecord *rec = &trace_buf[trace_idx];
144
145 if (!trace_list[event].state) {
146 return;
147 }
148
149 rec->event = event;
150 rec->timestamp_ns = get_clock();
151 rec->x1 = x1;
152 rec->x2 = x2;
153 rec->x3 = x3;
154 rec->x4 = x4;
155 rec->x5 = x5;
156 rec->x6 = x6;
157
158 if (++trace_idx == TRACE_BUF_LEN) {
159 st_flush_trace_buffer();
160 }
161 }
162
163 void trace0(TraceEventID event)
164 {
165 trace(event, 0, 0, 0, 0, 0, 0);
166 }
167
168 void trace1(TraceEventID event, uint64_t x1)
169 {
170 trace(event, x1, 0, 0, 0, 0, 0);
171 }
172
173 void trace2(TraceEventID event, uint64_t x1, uint64_t x2)
174 {
175 trace(event, x1, x2, 0, 0, 0, 0);
176 }
177
178 void trace3(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3)
179 {
180 trace(event, x1, x2, x3, 0, 0, 0);
181 }
182
183 void trace4(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4)
184 {
185 trace(event, x1, x2, x3, x4, 0, 0);
186 }
187
188 void trace5(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5)
189 {
190 trace(event, x1, x2, x3, x4, x5, 0);
191 }
192
193 void trace6(TraceEventID event, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5, uint64_t x6)
194 {
195 trace(event, x1, x2, x3, x4, x5, x6);
196 }
197
198 /**
199 * Flush the trace buffer on exit
200 */
201 static void __attribute__((constructor)) st_init(void)
202 {
203 atexit(st_flush_trace_buffer);
204 }
205
206 void st_print_trace(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
207 {
208 unsigned int i;
209
210 for (i = 0; i < trace_idx; i++) {
211 stream_printf(stream, "Event %" PRIu64 " : %" PRIx64 " %" PRIx64
212 " %" PRIx64 " %" PRIx64 " %" PRIx64 " %" PRIx64 "\n",
213 trace_buf[i].event, trace_buf[i].x1, trace_buf[i].x2,
214 trace_buf[i].x3, trace_buf[i].x4, trace_buf[i].x5,
215 trace_buf[i].x6);
216 }
217 }
218
219 void st_print_trace_events(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
220 {
221 unsigned int i;
222
223 for (i = 0; i < NR_TRACE_EVENTS; i++) {
224 stream_printf(stream, "%s [Event ID %u] : state %u\n",
225 trace_list[i].tp_name, i, trace_list[i].state);
226 }
227 }
228
229 static TraceEvent* find_trace_event_by_name(const char *tname)
230 {
231 unsigned int i;
232
233 if (!tname) {
234 return NULL;
235 }
236
237 for (i = 0; i < NR_TRACE_EVENTS; i++) {
238 if (!strcmp(trace_list[i].tp_name, tname)) {
239 return &trace_list[i];
240 }
241 }
242 return NULL; /* indicates end of list reached without a match */
243 }
244
245 bool st_change_trace_event_state(const char *tname, bool tstate)
246 {
247 TraceEvent *tp;
248
249 tp = find_trace_event_by_name(tname);
250 if (tp) {
251 tp->state = tstate;
252 return true;
253 }
254 return false;
255 }
Something went wrong with that request. Please try again.