Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Interface for configuring and controlling the state of tracing events. |
| 3 | * |
Lluís Vilanova | 4815185 | 2016-07-11 12:53:41 +0200 | [diff] [blame] | 4 | * Copyright (C) 2011-2016 Lluís Vilanova <vilanova@ac.upc.edu> |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 5 | * |
Lluís Vilanova | b1bae81 | 2013-03-05 14:47:38 +0100 | [diff] [blame] | 6 | * This work is licensed under the terms of the GNU GPL, version 2 or later. |
| 7 | * See the COPYING file in the top-level directory. |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 8 | */ |
| 9 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 10 | #include "qemu/osdep.h" |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 11 | #include "trace/control.h" |
Veronia Bahaa | f348b6d | 2016-03-20 19:16:19 +0200 | [diff] [blame] | 12 | #include "qemu/help_option.h" |
Markus Armbruster | 922a01a | 2018-02-01 12:18:46 +0100 | [diff] [blame] | 13 | #include "qemu/option.h" |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 14 | #ifdef CONFIG_TRACE_SIMPLE |
| 15 | #include "trace/simple.h" |
| 16 | #endif |
| 17 | #ifdef CONFIG_TRACE_FTRACE |
| 18 | #include "trace/ftrace.h" |
| 19 | #endif |
Paolo Bonzini | ed7f5f1 | 2016-01-07 16:55:30 +0300 | [diff] [blame] | 20 | #ifdef CONFIG_TRACE_LOG |
| 21 | #include "qemu/log.h" |
| 22 | #endif |
Paul Durrant | 0a85241 | 2016-08-04 14:44:14 +0100 | [diff] [blame] | 23 | #ifdef CONFIG_TRACE_SYSLOG |
| 24 | #include <syslog.h> |
| 25 | #endif |
Markus Armbruster | daa76aa | 2016-06-15 19:27:16 +0200 | [diff] [blame] | 26 | #include "qapi/error.h" |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 27 | #include "qemu/error-report.h" |
Denis V. Lunev | e9e0bb2 | 2016-06-17 17:44:10 +0300 | [diff] [blame] | 28 | #include "qemu/config-file.h" |
Denis V. Lunev | acc6809 | 2016-03-16 14:36:51 +0300 | [diff] [blame] | 29 | #include "monitor/monitor.h" |
Daniel P. Berrange | 0ab8ed1 | 2017-01-25 16:14:15 +0000 | [diff] [blame] | 30 | #include "trace-root.h" |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 31 | |
Paolo Bonzini | 43b48cf | 2015-10-28 07:06:26 +0100 | [diff] [blame] | 32 | int trace_events_enabled_count; |
| 33 | |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 34 | typedef struct TraceEventGroup { |
| 35 | TraceEvent **events; |
| 36 | } TraceEventGroup; |
| 37 | |
| 38 | static TraceEventGroup *event_groups; |
| 39 | static size_t nevent_groups; |
Daniel P. Berrange | ca3fa0e | 2016-10-04 14:35:54 +0100 | [diff] [blame] | 40 | static uint32_t next_id; |
| 41 | static uint32_t next_vcpu_id; |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 42 | |
Denis V. Lunev | e9e0bb2 | 2016-06-17 17:44:10 +0300 | [diff] [blame] | 43 | QemuOptsList qemu_trace_opts = { |
| 44 | .name = "trace", |
| 45 | .implied_opt_name = "enable", |
| 46 | .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head), |
| 47 | .desc = { |
| 48 | { |
| 49 | .name = "enable", |
| 50 | .type = QEMU_OPT_STRING, |
| 51 | }, |
| 52 | { |
| 53 | .name = "events", |
| 54 | .type = QEMU_OPT_STRING, |
| 55 | },{ |
| 56 | .name = "file", |
| 57 | .type = QEMU_OPT_STRING, |
| 58 | }, |
| 59 | { /* end of list */ } |
| 60 | }, |
| 61 | }; |
| 62 | |
| 63 | |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 64 | void trace_event_register_group(TraceEvent **events) |
| 65 | { |
Daniel P. Berrange | ca3fa0e | 2016-10-04 14:35:54 +0100 | [diff] [blame] | 66 | size_t i; |
| 67 | for (i = 0; events[i] != NULL; i++) { |
| 68 | events[i]->id = next_id++; |
Lluís Vilanova | d01c05c | 2017-07-04 10:34:19 +0200 | [diff] [blame] | 69 | if (events[i]->vcpu_id == TRACE_VCPU_EVENT_NONE) { |
| 70 | continue; |
| 71 | } |
| 72 | |
| 73 | if (likely(next_vcpu_id < CPU_TRACE_DSTATE_MAX_EVENTS)) { |
Daniel P. Berrange | ca3fa0e | 2016-10-04 14:35:54 +0100 | [diff] [blame] | 74 | events[i]->vcpu_id = next_vcpu_id++; |
Lluís Vilanova | d01c05c | 2017-07-04 10:34:19 +0200 | [diff] [blame] | 75 | } else { |
Alistair Francis | 55d527a | 2017-09-11 12:52:46 -0700 | [diff] [blame] | 76 | warn_report("too many vcpu trace events; dropping '%s'", |
| 77 | events[i]->name); |
Daniel P. Berrange | ca3fa0e | 2016-10-04 14:35:54 +0100 | [diff] [blame] | 78 | } |
| 79 | } |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 80 | event_groups = g_renew(TraceEventGroup, event_groups, nevent_groups + 1); |
| 81 | event_groups[nevent_groups].events = events; |
| 82 | nevent_groups++; |
| 83 | } |
| 84 | |
| 85 | |
Lluís Vilanova | b1bae81 | 2013-03-05 14:47:38 +0100 | [diff] [blame] | 86 | TraceEvent *trace_event_name(const char *name) |
| 87 | { |
| 88 | assert(name != NULL); |
| 89 | |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 90 | TraceEventIter iter; |
| 91 | TraceEvent *ev; |
| 92 | trace_event_iter_init(&iter, NULL); |
| 93 | while ((ev = trace_event_iter_next(&iter)) != NULL) { |
Lluís Vilanova | b1bae81 | 2013-03-05 14:47:38 +0100 | [diff] [blame] | 94 | if (strcmp(trace_event_get_name(ev), name) == 0) { |
| 95 | return ev; |
| 96 | } |
| 97 | } |
| 98 | return NULL; |
| 99 | } |
| 100 | |
Daniel P. Berrange | 6a1b0f3 | 2016-10-04 14:35:42 +0100 | [diff] [blame] | 101 | void trace_event_iter_init(TraceEventIter *iter, const char *pattern) |
| 102 | { |
| 103 | iter->event = 0; |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 104 | iter->group = 0; |
Daniel P. Berrange | 6a1b0f3 | 2016-10-04 14:35:42 +0100 | [diff] [blame] | 105 | iter->pattern = pattern; |
| 106 | } |
| 107 | |
| 108 | TraceEvent *trace_event_iter_next(TraceEventIter *iter) |
| 109 | { |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 110 | while (iter->group < nevent_groups && |
| 111 | event_groups[iter->group].events[iter->event] != NULL) { |
| 112 | TraceEvent *ev = event_groups[iter->group].events[iter->event]; |
Daniel P. Berrange | 6a1b0f3 | 2016-10-04 14:35:42 +0100 | [diff] [blame] | 113 | iter->event++; |
Daniel P. Berrange | fe4db84 | 2016-10-04 14:35:52 +0100 | [diff] [blame] | 114 | if (event_groups[iter->group].events[iter->event] == NULL) { |
| 115 | iter->event = 0; |
| 116 | iter->group++; |
| 117 | } |
Daniel P. Berrange | 6a1b0f3 | 2016-10-04 14:35:42 +0100 | [diff] [blame] | 118 | if (!iter->pattern || |
Alex Bennée | e66eae7 | 2019-12-05 12:25:17 +0000 | [diff] [blame] | 119 | g_pattern_match_simple(iter->pattern, trace_event_get_name(ev))) { |
Daniel P. Berrange | 6a1b0f3 | 2016-10-04 14:35:42 +0100 | [diff] [blame] | 120 | return ev; |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | return NULL; |
| 125 | } |
| 126 | |
Paolo Bonzini | e9527dd | 2016-01-07 16:55:27 +0300 | [diff] [blame] | 127 | void trace_list_events(void) |
| 128 | { |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 129 | TraceEventIter iter; |
| 130 | TraceEvent *ev; |
| 131 | trace_event_iter_init(&iter, NULL); |
| 132 | while ((ev = trace_event_iter_next(&iter)) != NULL) { |
| 133 | fprintf(stderr, "%s\n", trace_event_get_name(ev)); |
Paolo Bonzini | e9527dd | 2016-01-07 16:55:27 +0300 | [diff] [blame] | 134 | } |
Philippe Mathieu-Daudé | 9f591a5 | 2019-08-23 16:22:03 +0200 | [diff] [blame] | 135 | #ifdef CONFIG_TRACE_DTRACE |
| 136 | fprintf(stderr, "This list of names of trace points may be incomplete " |
| 137 | "when using the DTrace/SystemTap backends.\n" |
| 138 | "Run 'qemu-trace-stap list %s' to print the full list.\n", |
| 139 | error_get_progname()); |
| 140 | #endif |
Paolo Bonzini | e9527dd | 2016-01-07 16:55:27 +0300 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | static void do_trace_enable_events(const char *line_buf) |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 144 | { |
| 145 | const bool enable = ('-' != line_buf[0]); |
| 146 | const char *line_ptr = enable ? line_buf : line_buf + 1; |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 147 | TraceEventIter iter; |
| 148 | TraceEvent *ev; |
| 149 | bool is_pattern = trace_event_is_pattern(line_ptr); |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 150 | |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 151 | trace_event_iter_init(&iter, line_ptr); |
| 152 | while ((ev = trace_event_iter_next(&iter)) != NULL) { |
| 153 | if (!trace_event_get_state_static(ev)) { |
| 154 | if (!is_pattern) { |
Alistair Francis | 3dc6f86 | 2017-07-12 06:57:41 -0700 | [diff] [blame] | 155 | warn_report("trace event '%s' is not traceable", |
| 156 | line_ptr); |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 157 | return; |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 158 | } |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 159 | continue; |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 160 | } |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 161 | |
| 162 | /* start tracing */ |
| 163 | trace_event_set_state_dynamic(ev, enable); |
| 164 | if (!is_pattern) { |
| 165 | return; |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 166 | } |
| 167 | } |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 168 | |
| 169 | if (!is_pattern) { |
Alistair Francis | 3dc6f86 | 2017-07-12 06:57:41 -0700 | [diff] [blame] | 170 | warn_report("trace event '%s' does not exist", |
| 171 | line_ptr); |
Daniel P. Berrange | 0d4e995 | 2016-10-04 14:35:43 +0100 | [diff] [blame] | 172 | } |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 173 | } |
| 174 | |
Paolo Bonzini | e9527dd | 2016-01-07 16:55:27 +0300 | [diff] [blame] | 175 | void trace_enable_events(const char *line_buf) |
| 176 | { |
| 177 | if (is_help_option(line_buf)) { |
| 178 | trace_list_events(); |
Denis V. Lunev | acc6809 | 2016-03-16 14:36:51 +0300 | [diff] [blame] | 179 | if (cur_mon == NULL) { |
| 180 | exit(0); |
| 181 | } |
Paolo Bonzini | e9527dd | 2016-01-07 16:55:27 +0300 | [diff] [blame] | 182 | } else { |
| 183 | do_trace_enable_events(line_buf); |
| 184 | } |
| 185 | } |
| 186 | |
Denis V. Lunev | e9e0bb2 | 2016-06-17 17:44:10 +0300 | [diff] [blame] | 187 | static void trace_init_events(const char *fname) |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 188 | { |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 189 | Location loc; |
| 190 | FILE *fp; |
| 191 | char line_buf[1024]; |
| 192 | size_t line_idx = 0; |
| 193 | |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 194 | if (fname == NULL) { |
| 195 | return; |
| 196 | } |
| 197 | |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 198 | loc_push_none(&loc); |
| 199 | loc_set_file(fname, 0); |
| 200 | fp = fopen(fname, "r"); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 201 | if (!fp) { |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 202 | error_report("%s", strerror(errno)); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 203 | exit(1); |
| 204 | } |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 205 | while (fgets(line_buf, sizeof(line_buf), fp)) { |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 206 | loc_set_file(fname, ++line_idx); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 207 | size_t len = strlen(line_buf); |
| 208 | if (len > 1) { /* skip empty lines */ |
| 209 | line_buf[len - 1] = '\0'; |
Alexey Kardashevskiy | 794b1f9 | 2012-06-14 14:41:40 +1000 | [diff] [blame] | 210 | if ('#' == line_buf[0]) { /* skip commented lines */ |
| 211 | continue; |
| 212 | } |
Paolo Bonzini | 10578a2 | 2016-01-07 16:55:26 +0300 | [diff] [blame] | 213 | trace_enable_events(line_buf); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 214 | } |
| 215 | } |
| 216 | if (fclose(fp) != 0) { |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 217 | loc_set_file(fname, 0); |
| 218 | error_report("%s", strerror(errno)); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 219 | exit(1); |
| 220 | } |
Alexey Kardashevskiy | a35d9be | 2014-06-02 16:34:10 +1000 | [diff] [blame] | 221 | loc_pop(&loc); |
Lluís | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 222 | } |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 223 | |
Paolo Bonzini | 41fc57e | 2016-01-07 16:55:24 +0300 | [diff] [blame] | 224 | void trace_init_file(const char *file) |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 225 | { |
| 226 | #ifdef CONFIG_TRACE_SIMPLE |
Paolo Bonzini | 41fc57e | 2016-01-07 16:55:24 +0300 | [diff] [blame] | 227 | st_set_trace_file(file); |
Paolo Bonzini | ed7f5f1 | 2016-01-07 16:55:30 +0300 | [diff] [blame] | 228 | #elif defined CONFIG_TRACE_LOG |
Alex Bennée | 3d88754 | 2020-02-25 12:47:00 +0000 | [diff] [blame^] | 229 | /* |
| 230 | * If both the simple and the log backends are enabled, "--trace file" |
| 231 | * only applies to the simple backend; use "-D" for the log |
| 232 | * backend. However we should only override -D if we actually have |
| 233 | * something to override it with. |
Paolo Bonzini | ed7f5f1 | 2016-01-07 16:55:30 +0300 | [diff] [blame] | 234 | */ |
Alex Bennée | 3d88754 | 2020-02-25 12:47:00 +0000 | [diff] [blame^] | 235 | if (file) { |
| 236 | qemu_set_log_filename(file, &error_fatal); |
| 237 | } |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 238 | #else |
| 239 | if (file) { |
Yaowei Bai | db817b8 | 2018-07-04 11:17:27 +0800 | [diff] [blame] | 240 | fprintf(stderr, "error: --trace file=...: " |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 241 | "option not supported by the selected tracing backends\n"); |
Paolo Bonzini | 41fc57e | 2016-01-07 16:55:24 +0300 | [diff] [blame] | 242 | exit(1); |
| 243 | } |
| 244 | #endif |
| 245 | } |
| 246 | |
Lluís Vilanova | 82e95ec | 2016-12-26 22:24:40 +0100 | [diff] [blame] | 247 | void trace_fini_vcpu(CPUState *vcpu) |
| 248 | { |
| 249 | TraceEventIter iter; |
| 250 | TraceEvent *ev; |
| 251 | |
Lluís Vilanova | a47e871 | 2016-12-26 22:24:46 +0100 | [diff] [blame] | 252 | trace_guest_cpu_exit(vcpu); |
| 253 | |
Lluís Vilanova | 82e95ec | 2016-12-26 22:24:40 +0100 | [diff] [blame] | 254 | trace_event_iter_init(&iter, NULL); |
| 255 | while ((ev = trace_event_iter_next(&iter)) != NULL) { |
| 256 | if (trace_event_is_vcpu(ev) && |
| 257 | trace_event_get_state_static(ev) && |
| 258 | trace_event_get_vcpu_state_dynamic(vcpu, ev)) { |
| 259 | /* must disable to affect the global counter */ |
| 260 | trace_event_set_vcpu_state_dynamic(vcpu, ev, false); |
| 261 | } |
| 262 | } |
| 263 | } |
| 264 | |
Paolo Bonzini | 41fc57e | 2016-01-07 16:55:24 +0300 | [diff] [blame] | 265 | bool trace_init_backends(void) |
| 266 | { |
| 267 | #ifdef CONFIG_TRACE_SIMPLE |
| 268 | if (!st_init()) { |
| 269 | fprintf(stderr, "failed to initialize simple tracing backend.\n"); |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 270 | return false; |
| 271 | } |
| 272 | #endif |
| 273 | |
| 274 | #ifdef CONFIG_TRACE_FTRACE |
| 275 | if (!ftrace_init()) { |
| 276 | fprintf(stderr, "failed to initialize ftrace backend.\n"); |
| 277 | return false; |
| 278 | } |
| 279 | #endif |
| 280 | |
Paul Durrant | 0a85241 | 2016-08-04 14:44:14 +0100 | [diff] [blame] | 281 | #ifdef CONFIG_TRACE_SYSLOG |
| 282 | openlog(NULL, LOG_PID, LOG_DAEMON); |
| 283 | #endif |
| 284 | |
Lluís Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 285 | return true; |
| 286 | } |
Denis V. Lunev | e9e0bb2 | 2016-06-17 17:44:10 +0300 | [diff] [blame] | 287 | |
| 288 | char *trace_opt_parse(const char *optarg) |
| 289 | { |
| 290 | char *trace_file; |
| 291 | QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("trace"), |
| 292 | optarg, true); |
| 293 | if (!opts) { |
| 294 | exit(1); |
| 295 | } |
| 296 | if (qemu_opt_get(opts, "enable")) { |
| 297 | trace_enable_events(qemu_opt_get(opts, "enable")); |
| 298 | } |
| 299 | trace_init_events(qemu_opt_get(opts, "events")); |
| 300 | trace_file = g_strdup(qemu_opt_get(opts, "file")); |
| 301 | qemu_opts_del(opts); |
| 302 | |
| 303 | return trace_file; |
| 304 | } |
Daniel P. Berrange | b7d4895 | 2016-10-04 14:35:53 +0100 | [diff] [blame] | 305 | |
| 306 | uint32_t trace_get_vcpu_event_count(void) |
| 307 | { |
Daniel P. Berrange | ca3fa0e | 2016-10-04 14:35:54 +0100 | [diff] [blame] | 308 | return next_vcpu_id; |
Daniel P. Berrange | b7d4895 | 2016-10-04 14:35:53 +0100 | [diff] [blame] | 309 | } |