#include <pthread.h>
#endif
#include "qemu/timer.h"
-#include "trace.h"
#include "trace/control.h"
#include "trace/simple.h"
+#include "qemu/error-report.h"
+#include "qemu/qemu-print.h"
-/** Trace file header event ID */
-#define HEADER_EVENT_ID (~(uint64_t)0) /* avoids conflicting with TraceEventIDs */
+/** Trace file header event ID, picked to avoid conflict with real event IDs */
+#define HEADER_EVENT_ID (~(uint64_t)0)
/** Trace file magic number */
#define HEADER_MAGIC 0xf2b177cb0aa429b4ULL
/** Trace file version number, bump if format changes */
-#define HEADER_VERSION 3
+#define HEADER_VERSION 4
/** Records were dropped event ID */
#define DROPPED_EVENT_ID (~(uint64_t)0 - 1)
* Trace records are written out by a dedicated thread. The thread waits for
* records to become available, writes them out, and then waits again.
*/
-static CompatGMutex trace_lock;
-static CompatGCond trace_available_cond;
-static CompatGCond trace_empty_cond;
+static GMutex trace_lock;
+static GCond trace_available_cond;
+static GCond trace_empty_cond;
static bool trace_available;
static bool trace_writeout_enabled;
static FILE *trace_fp;
static char *trace_file_name;
+#define TRACE_RECORD_TYPE_MAPPING 0
+#define TRACE_RECORD_TYPE_EVENT 1
+
/* * Trace buffer entry */
typedef struct {
- uint64_t event; /* TraceEventID */
+ uint64_t event; /* event ID value */
uint64_t timestamp_ns;
uint32_t length; /* in bytes */
uint32_t pid;
unsigned int idx = 0;
int dropped_count;
size_t unused __attribute__ ((unused));
+ uint64_t type = TRACE_RECORD_TYPE_EVENT;
for (;;) {
wait_for_trace_records_available();
if (g_atomic_int_get(&dropped_events)) {
- dropped.rec.event = DROPPED_EVENT_ID,
+ dropped.rec.event = DROPPED_EVENT_ID;
dropped.rec.timestamp_ns = get_clock();
- dropped.rec.length = sizeof(TraceRecord) + sizeof(uint64_t),
+ dropped.rec.length = sizeof(TraceRecord) + sizeof(uint64_t);
dropped.rec.pid = trace_pid;
do {
dropped_count = g_atomic_int_get(&dropped_events);
} while (!g_atomic_int_compare_and_exchange(&dropped_events,
dropped_count, 0));
dropped.rec.arguments[0] = dropped_count;
+ unused = fwrite(&type, sizeof(type), 1, trace_fp);
unused = fwrite(&dropped.rec, dropped.rec.length, 1, trace_fp);
}
while (get_trace_record(idx, &recordptr)) {
+ unused = fwrite(&type, sizeof(type), 1, trace_fp);
unused = fwrite(recordptr, recordptr->length, 1, trace_fp);
writeout_idx += recordptr->length;
free(recordptr); /* don't use g_free, can deadlock when traced */
rec->rec_off = write_to_buffer(rec->rec_off, (void*)s, slen);
}
-int trace_record_start(TraceBufferRecord *rec, TraceEventID event, size_t datasize)
+int trace_record_start(TraceBufferRecord *rec, uint32_t event, size_t datasize)
{
unsigned int idx, rec_off, old_idx, new_idx;
uint32_t rec_len = sizeof(TraceRecord) + datasize;
}
}
-void st_set_trace_file_enabled(bool enable)
+static int st_write_event_mapping(TraceEventIter *iter)
+{
+ uint64_t type = TRACE_RECORD_TYPE_MAPPING;
+ TraceEvent *ev;
+
+ while ((ev = trace_event_iter_next(iter)) != NULL) {
+ uint64_t id = trace_event_get_id(ev);
+ const char *name = trace_event_get_name(ev);
+ uint32_t len = strlen(name);
+ if (fwrite(&type, sizeof(type), 1, trace_fp) != 1 ||
+ fwrite(&id, sizeof(id), 1, trace_fp) != 1 ||
+ fwrite(&len, sizeof(len), 1, trace_fp) != 1 ||
+ fwrite(name, len, 1, trace_fp) != 1) {
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Enable / disable tracing, return whether it was enabled.
+ *
+ * @enable: enable if %true, else disable.
+ */
+bool st_set_trace_file_enabled(bool enable)
{
+ TraceEventIter iter;
+ bool was_enabled = trace_fp;
+
if (enable == !!trace_fp) {
- return; /* no change */
+ return was_enabled; /* no change */
}
/* Halt trace writeout */
trace_fp = fopen(trace_file_name, "wb");
if (!trace_fp) {
- return;
+ return was_enabled;
}
- if (fwrite(&header, sizeof header, 1, trace_fp) != 1) {
+ trace_event_iter_init_all(&iter);
+ if (fwrite(&header, sizeof header, 1, trace_fp) != 1 ||
+ st_write_event_mapping(&iter) < 0) {
fclose(trace_fp);
trace_fp = NULL;
- return;
+ return was_enabled;
}
/* Resume trace writeout */
fclose(trace_fp);
trace_fp = NULL;
}
+ return was_enabled;
}
/**
*/
void st_set_trace_file(const char *file)
{
- st_set_trace_file_enabled(false);
+ bool saved_enable = st_set_trace_file_enabled(false);
g_free(trace_file_name);
if (!file) {
/* Type cast needed for Windows where getpid() returns an int. */
- trace_file_name = g_strdup_printf(CONFIG_TRACE_FILE, (pid_t)getpid());
+ trace_file_name = g_strdup_printf(CONFIG_TRACE_FILE "-" FMT_pid, (pid_t)getpid());
} else {
trace_file_name = g_strdup_printf("%s", file);
}
- st_set_trace_file_enabled(true);
+ st_set_trace_file_enabled(saved_enable);
}
-void st_print_trace_file_status(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
+void st_print_trace_file_status(void)
{
- stream_printf(stream, "Trace file \"%s\" %s.\n",
- trace_file_name, trace_fp ? "on" : "off");
+ qemu_printf("Trace file \"%s\" %s.\n",
+ trace_file_name, trace_fp ? "on" : "off");
}
void st_flush_trace_buffer(void)
thread = trace_thread_create(writeout_thread);
if (!thread) {
- fprintf(stderr, "warning: unable to initialize simple trace backend\n");
+ warn_report("unable to initialize simple trace backend");
return false;
}
atexit(st_flush_trace_buffer);
return true;
}
+
+void st_init_group(size_t group)
+{
+ TraceEventIter iter;
+
+ if (!trace_writeout_enabled) {
+ return;
+ }
+
+ trace_event_iter_init_group(&iter, group);
+ st_write_event_mapping(&iter);
+}