4 * Copyright IBM, Corp. 2010
6 * This work is licensed under the terms of the GNU GPL, version 2. See
7 * the COPYING file in the top-level directory.
19 #include "qemu/timer.h"
21 #include "trace/control.h"
23 /** Trace file header event ID */
24 #define HEADER_EVENT_ID (~(uint64_t)0) /* avoids conflicting with TraceEventIDs */
26 /** Trace file magic number */
27 #define HEADER_MAGIC 0xf2b177cb0aa429b4ULL
29 /** Trace file version number, bump if format changes */
30 #define HEADER_VERSION 2
32 /** Records were dropped event ID */
33 #define DROPPED_EVENT_ID (~(uint64_t)0 - 1)
35 /** Trace record is valid */
36 #define TRACE_RECORD_VALID ((uint64_t)1 << 63)
39 * Trace records are written out by a dedicated thread. The thread waits for
40 * records to become available, writes them out, and then waits again.
42 static GStaticMutex trace_lock
= G_STATIC_MUTEX_INIT
;
43 static GCond
*trace_available_cond
;
44 static GCond
*trace_empty_cond
;
45 static bool trace_available
;
46 static bool trace_writeout_enabled
;
49 TRACE_BUF_LEN
= 4096 * 64,
50 TRACE_BUF_FLUSH_THRESHOLD
= TRACE_BUF_LEN
/ 4,
53 uint8_t trace_buf
[TRACE_BUF_LEN
];
54 static unsigned int trace_idx
;
55 static unsigned int writeout_idx
;
56 static int dropped_events
;
57 static FILE *trace_fp
;
58 static char *trace_file_name
;
60 /* * Trace buffer entry */
62 uint64_t event
; /* TraceEventID */
63 uint64_t timestamp_ns
;
64 uint32_t length
; /* in bytes */
65 uint32_t reserved
; /* unused */
70 uint64_t header_event_id
; /* HEADER_EVENT_ID */
71 uint64_t header_magic
; /* HEADER_MAGIC */
72 uint64_t header_version
; /* HEADER_VERSION */
76 static void read_from_buffer(unsigned int idx
, void *dataptr
, size_t size
);
77 static unsigned int write_to_buffer(unsigned int idx
, void *dataptr
, size_t size
);
79 static void clear_buffer_range(unsigned int idx
, size_t len
)
83 if (idx
>= TRACE_BUF_LEN
) {
84 idx
= idx
% TRACE_BUF_LEN
;
91 * Read a trace record from the trace buffer
93 * @idx Trace buffer index
94 * @record Trace record to fill
96 * Returns false if the record is not valid.
98 static bool get_trace_record(unsigned int idx
, TraceRecord
**recordptr
)
100 uint64_t event_flag
= 0;
102 /* read the event flag to see if its a valid record */
103 read_from_buffer(idx
, &record
, sizeof(event_flag
));
105 if (!(record
.event
& TRACE_RECORD_VALID
)) {
109 smp_rmb(); /* read memory barrier before accessing record */
110 /* read the record header to know record length */
111 read_from_buffer(idx
, &record
, sizeof(TraceRecord
));
112 *recordptr
= malloc(record
.length
); /* dont use g_malloc, can deadlock when traced */
113 /* make a copy of record to avoid being overwritten */
114 read_from_buffer(idx
, *recordptr
, record
.length
);
115 smp_rmb(); /* memory barrier before clearing valid flag */
116 (*recordptr
)->event
&= ~TRACE_RECORD_VALID
;
117 /* clear the trace buffer range for consumed record otherwise any byte
118 * with its MSB set may be considered as a valid event id when the writer
119 * thread crosses this range of buffer again.
121 clear_buffer_range(idx
, record
.length
);
126 * Kick writeout thread
128 * @wait Whether to wait for writeout thread to complete
130 static void flush_trace_file(bool wait
)
132 g_static_mutex_lock(&trace_lock
);
133 trace_available
= true;
134 g_cond_signal(trace_available_cond
);
137 g_cond_wait(trace_empty_cond
, g_static_mutex_get_mutex(&trace_lock
));
140 g_static_mutex_unlock(&trace_lock
);
143 static void wait_for_trace_records_available(void)
145 g_static_mutex_lock(&trace_lock
);
146 while (!(trace_available
&& trace_writeout_enabled
)) {
147 g_cond_signal(trace_empty_cond
);
148 g_cond_wait(trace_available_cond
,
149 g_static_mutex_get_mutex(&trace_lock
));
151 trace_available
= false;
152 g_static_mutex_unlock(&trace_lock
);
155 static gpointer
writeout_thread(gpointer opaque
)
157 TraceRecord
*recordptr
;
160 uint8_t bytes
[sizeof(TraceRecord
) + sizeof(uint64_t)];
162 unsigned int idx
= 0;
164 size_t unused
__attribute__ ((unused
));
167 wait_for_trace_records_available();
169 if (g_atomic_int_get(&dropped_events
)) {
170 dropped
.rec
.event
= DROPPED_EVENT_ID
,
171 dropped
.rec
.timestamp_ns
= get_clock();
172 dropped
.rec
.length
= sizeof(TraceRecord
) + sizeof(uint64_t),
173 dropped
.rec
.reserved
= 0;
175 dropped_count
= g_atomic_int_get(&dropped_events
);
176 } while (!g_atomic_int_compare_and_exchange(&dropped_events
,
178 dropped
.rec
.arguments
[0] = dropped_count
;
179 unused
= fwrite(&dropped
.rec
, dropped
.rec
.length
, 1, trace_fp
);
182 while (get_trace_record(idx
, &recordptr
)) {
183 unused
= fwrite(recordptr
, recordptr
->length
, 1, trace_fp
);
184 writeout_idx
+= recordptr
->length
;
185 free(recordptr
); /* dont use g_free, can deadlock when traced */
186 idx
= writeout_idx
% TRACE_BUF_LEN
;
194 void trace_record_write_u64(TraceBufferRecord
*rec
, uint64_t val
)
196 rec
->rec_off
= write_to_buffer(rec
->rec_off
, &val
, sizeof(uint64_t));
199 void trace_record_write_str(TraceBufferRecord
*rec
, const char *s
, uint32_t slen
)
201 /* Write string length first */
202 rec
->rec_off
= write_to_buffer(rec
->rec_off
, &slen
, sizeof(slen
));
203 /* Write actual string now */
204 rec
->rec_off
= write_to_buffer(rec
->rec_off
, (void*)s
, slen
);
207 int trace_record_start(TraceBufferRecord
*rec
, TraceEventID event
, size_t datasize
)
209 unsigned int idx
, rec_off
, old_idx
, new_idx
;
210 uint32_t rec_len
= sizeof(TraceRecord
) + datasize
;
211 uint64_t timestamp_ns
= get_clock();
214 old_idx
= g_atomic_int_get(&trace_idx
);
216 new_idx
= old_idx
+ rec_len
;
218 if (new_idx
- writeout_idx
> TRACE_BUF_LEN
) {
219 /* Trace Buffer Full, Event dropped ! */
220 g_atomic_int_inc(&dropped_events
);
223 } while (!g_atomic_int_compare_and_exchange(&trace_idx
, old_idx
, new_idx
));
225 idx
= old_idx
% TRACE_BUF_LEN
;
228 rec_off
= write_to_buffer(rec_off
, &event
, sizeof(event
));
229 rec_off
= write_to_buffer(rec_off
, ×tamp_ns
, sizeof(timestamp_ns
));
230 rec_off
= write_to_buffer(rec_off
, &rec_len
, sizeof(rec_len
));
233 rec
->rec_off
= (idx
+ sizeof(TraceRecord
)) % TRACE_BUF_LEN
;
237 static void read_from_buffer(unsigned int idx
, void *dataptr
, size_t size
)
239 uint8_t *data_ptr
= dataptr
;
242 if (idx
>= TRACE_BUF_LEN
) {
243 idx
= idx
% TRACE_BUF_LEN
;
245 data_ptr
[x
++] = trace_buf
[idx
++];
249 static unsigned int write_to_buffer(unsigned int idx
, void *dataptr
, size_t size
)
251 uint8_t *data_ptr
= dataptr
;
254 if (idx
>= TRACE_BUF_LEN
) {
255 idx
= idx
% TRACE_BUF_LEN
;
257 trace_buf
[idx
++] = data_ptr
[x
++];
259 return idx
; /* most callers wants to know where to write next */
262 void trace_record_finish(TraceBufferRecord
*rec
)
265 read_from_buffer(rec
->tbuf_idx
, &record
, sizeof(TraceRecord
));
266 smp_wmb(); /* write barrier before marking as valid */
267 record
.event
|= TRACE_RECORD_VALID
;
268 write_to_buffer(rec
->tbuf_idx
, &record
, sizeof(TraceRecord
));
270 if ((g_atomic_int_get(&trace_idx
) - writeout_idx
)
271 > TRACE_BUF_FLUSH_THRESHOLD
) {
272 flush_trace_file(false);
276 void st_set_trace_file_enabled(bool enable
)
278 if (enable
== !!trace_fp
) {
279 return; /* no change */
282 /* Halt trace writeout */
283 flush_trace_file(true);
284 trace_writeout_enabled
= false;
285 flush_trace_file(true);
288 static const TraceLogHeader header
= {
289 .header_event_id
= HEADER_EVENT_ID
,
290 .header_magic
= HEADER_MAGIC
,
291 /* Older log readers will check for version at next location */
292 .header_version
= HEADER_VERSION
,
295 trace_fp
= fopen(trace_file_name
, "wb");
300 if (fwrite(&header
, sizeof header
, 1, trace_fp
) != 1) {
306 /* Resume trace writeout */
307 trace_writeout_enabled
= true;
308 flush_trace_file(false);
316 * Set the name of a trace file
318 * @file The trace file name or NULL for the default name-<pid> set at
321 bool st_set_trace_file(const char *file
)
323 st_set_trace_file_enabled(false);
325 g_free(trace_file_name
);
328 trace_file_name
= g_strdup_printf(CONFIG_TRACE_FILE
, getpid());
330 trace_file_name
= g_strdup_printf("%s", file
);
333 st_set_trace_file_enabled(true);
337 void st_print_trace_file_status(FILE *stream
, int (*stream_printf
)(FILE *stream
, const char *fmt
, ...))
339 stream_printf(stream
, "Trace file \"%s\" %s.\n",
340 trace_file_name
, trace_fp
? "on" : "off");
343 void st_flush_trace_buffer(void)
345 flush_trace_file(true);
348 void trace_print_events(FILE *stream
, fprintf_function stream_printf
)
352 for (i
= 0; i
< NR_TRACE_EVENTS
; i
++) {
353 stream_printf(stream
, "%s [Event ID %u] : state %u\n",
354 trace_list
[i
].tp_name
, i
, trace_list
[i
].state
);
358 bool trace_event_set_state(const char *name
, bool state
)
362 bool wildcard
= false;
363 bool matched
= false;
366 if (len
> 0 && name
[len
- 1] == '*') {
370 for (i
= 0; i
< NR_TRACE_EVENTS
; i
++) {
372 if (!strncmp(trace_list
[i
].tp_name
, name
, len
)) {
373 trace_list
[i
].state
= state
;
378 if (!strcmp(trace_list
[i
].tp_name
, name
)) {
379 trace_list
[i
].state
= state
;
386 /* Helper function to create a thread with signals blocked. Use glib's
387 * portable threads since QEMU abstractions cannot be used due to reentrancy in
388 * the tracer. Also note the signal masking on POSIX hosts so that the thread
389 * does not steal signals when the rest of the program wants them blocked.
391 static GThread
*trace_thread_create(GThreadFunc fn
)
395 sigset_t set
, oldset
;
398 pthread_sigmask(SIG_SETMASK
, &set
, &oldset
);
400 thread
= g_thread_create(fn
, NULL
, FALSE
, NULL
);
402 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
408 bool trace_backend_init(const char *events
, const char *file
)
412 if (!g_thread_supported()) {
413 #if !GLIB_CHECK_VERSION(2, 31, 0)
416 fprintf(stderr
, "glib threading failed to initialize.\n");
421 trace_available_cond
= g_cond_new();
422 trace_empty_cond
= g_cond_new();
424 thread
= trace_thread_create(writeout_thread
);
426 fprintf(stderr
, "warning: unable to initialize simple trace backend\n");
430 atexit(st_flush_trace_buffer
);
431 trace_backend_init_events(events
);
432 st_set_trace_file(file
);