Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-03-16' into staging
[qemu.git] / trace / control.c
1 /*
2 * Interface for configuring and controlling the state of tracing events.
3 *
4 * Copyright (C) 2011-2016 LluĂ­s Vilanova <vilanova@ac.upc.edu>
5 *
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.
8 */
9
10 #include "qemu/osdep.h"
11 #include "trace/control.h"
12 #include "qemu/help_option.h"
13 #ifdef CONFIG_TRACE_SIMPLE
14 #include "trace/simple.h"
15 #endif
16 #ifdef CONFIG_TRACE_FTRACE
17 #include "trace/ftrace.h"
18 #endif
19 #ifdef CONFIG_TRACE_LOG
20 #include "qemu/log.h"
21 #endif
22 #ifdef CONFIG_TRACE_SYSLOG
23 #include <syslog.h>
24 #endif
25 #include "qapi/error.h"
26 #include "qemu/error-report.h"
27 #include "qemu/config-file.h"
28 #include "monitor/monitor.h"
29 #include "trace-root.h"
30
31 int trace_events_enabled_count;
32
33 typedef struct TraceEventGroup {
34 TraceEvent **events;
35 } TraceEventGroup;
36
37 static TraceEventGroup *event_groups;
38 static size_t nevent_groups;
39 static uint32_t next_id;
40 static uint32_t next_vcpu_id;
41
42 QemuOptsList qemu_trace_opts = {
43 .name = "trace",
44 .implied_opt_name = "enable",
45 .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
46 .desc = {
47 {
48 .name = "enable",
49 .type = QEMU_OPT_STRING,
50 },
51 {
52 .name = "events",
53 .type = QEMU_OPT_STRING,
54 },{
55 .name = "file",
56 .type = QEMU_OPT_STRING,
57 },
58 { /* end of list */ }
59 },
60 };
61
62
63 void trace_event_register_group(TraceEvent **events)
64 {
65 size_t i;
66 for (i = 0; events[i] != NULL; i++) {
67 events[i]->id = next_id++;
68 if (events[i]->vcpu_id != TRACE_VCPU_EVENT_NONE) {
69 events[i]->vcpu_id = next_vcpu_id++;
70 }
71 }
72 event_groups = g_renew(TraceEventGroup, event_groups, nevent_groups + 1);
73 event_groups[nevent_groups].events = events;
74 nevent_groups++;
75 }
76
77
78 TraceEvent *trace_event_name(const char *name)
79 {
80 assert(name != NULL);
81
82 TraceEventIter iter;
83 TraceEvent *ev;
84 trace_event_iter_init(&iter, NULL);
85 while ((ev = trace_event_iter_next(&iter)) != NULL) {
86 if (strcmp(trace_event_get_name(ev), name) == 0) {
87 return ev;
88 }
89 }
90 return NULL;
91 }
92
93 static bool pattern_glob(const char *pat, const char *ev)
94 {
95 while (*pat != '\0' && *ev != '\0') {
96 if (*pat == *ev) {
97 pat++;
98 ev++;
99 }
100 else if (*pat == '*') {
101 if (pattern_glob(pat, ev+1)) {
102 return true;
103 } else if (pattern_glob(pat+1, ev)) {
104 return true;
105 } else {
106 return false;
107 }
108 } else {
109 return false;
110 }
111 }
112
113 while (*pat == '*') {
114 pat++;
115 }
116
117 if (*pat == '\0' && *ev == '\0') {
118 return true;
119 } else {
120 return false;
121 }
122 }
123
124
125 void trace_event_iter_init(TraceEventIter *iter, const char *pattern)
126 {
127 iter->event = 0;
128 iter->group = 0;
129 iter->pattern = pattern;
130 }
131
132 TraceEvent *trace_event_iter_next(TraceEventIter *iter)
133 {
134 while (iter->group < nevent_groups &&
135 event_groups[iter->group].events[iter->event] != NULL) {
136 TraceEvent *ev = event_groups[iter->group].events[iter->event];
137 iter->event++;
138 if (event_groups[iter->group].events[iter->event] == NULL) {
139 iter->event = 0;
140 iter->group++;
141 }
142 if (!iter->pattern ||
143 pattern_glob(iter->pattern,
144 trace_event_get_name(ev))) {
145 return ev;
146 }
147 }
148
149 return NULL;
150 }
151
152 void trace_list_events(void)
153 {
154 TraceEventIter iter;
155 TraceEvent *ev;
156 trace_event_iter_init(&iter, NULL);
157 while ((ev = trace_event_iter_next(&iter)) != NULL) {
158 fprintf(stderr, "%s\n", trace_event_get_name(ev));
159 }
160 }
161
162 static void do_trace_enable_events(const char *line_buf)
163 {
164 const bool enable = ('-' != line_buf[0]);
165 const char *line_ptr = enable ? line_buf : line_buf + 1;
166 TraceEventIter iter;
167 TraceEvent *ev;
168 bool is_pattern = trace_event_is_pattern(line_ptr);
169
170 trace_event_iter_init(&iter, line_ptr);
171 while ((ev = trace_event_iter_next(&iter)) != NULL) {
172 if (!trace_event_get_state_static(ev)) {
173 if (!is_pattern) {
174 error_report("WARNING: trace event '%s' is not traceable",
175 line_ptr);
176 return;
177 }
178 continue;
179 }
180
181 /* start tracing */
182 trace_event_set_state_dynamic(ev, enable);
183 if (!is_pattern) {
184 return;
185 }
186 }
187
188 if (!is_pattern) {
189 error_report("WARNING: trace event '%s' does not exist",
190 line_ptr);
191 }
192 }
193
194 void trace_enable_events(const char *line_buf)
195 {
196 if (is_help_option(line_buf)) {
197 trace_list_events();
198 if (cur_mon == NULL) {
199 exit(0);
200 }
201 } else {
202 do_trace_enable_events(line_buf);
203 }
204 }
205
206 static void trace_init_events(const char *fname)
207 {
208 Location loc;
209 FILE *fp;
210 char line_buf[1024];
211 size_t line_idx = 0;
212
213 if (fname == NULL) {
214 return;
215 }
216
217 loc_push_none(&loc);
218 loc_set_file(fname, 0);
219 fp = fopen(fname, "r");
220 if (!fp) {
221 error_report("%s", strerror(errno));
222 exit(1);
223 }
224 while (fgets(line_buf, sizeof(line_buf), fp)) {
225 loc_set_file(fname, ++line_idx);
226 size_t len = strlen(line_buf);
227 if (len > 1) { /* skip empty lines */
228 line_buf[len - 1] = '\0';
229 if ('#' == line_buf[0]) { /* skip commented lines */
230 continue;
231 }
232 trace_enable_events(line_buf);
233 }
234 }
235 if (fclose(fp) != 0) {
236 loc_set_file(fname, 0);
237 error_report("%s", strerror(errno));
238 exit(1);
239 }
240 loc_pop(&loc);
241 }
242
243 void trace_init_file(const char *file)
244 {
245 #ifdef CONFIG_TRACE_SIMPLE
246 st_set_trace_file(file);
247 #elif defined CONFIG_TRACE_LOG
248 /* If both the simple and the log backends are enabled, "-trace file"
249 * only applies to the simple backend; use "-D" for the log backend.
250 */
251 if (file) {
252 qemu_set_log_filename(file, &error_fatal);
253 }
254 #else
255 if (file) {
256 fprintf(stderr, "error: -trace file=...: "
257 "option not supported by the selected tracing backends\n");
258 exit(1);
259 }
260 #endif
261 }
262
263 void trace_fini_vcpu(CPUState *vcpu)
264 {
265 TraceEventIter iter;
266 TraceEvent *ev;
267
268 trace_guest_cpu_exit(vcpu);
269
270 trace_event_iter_init(&iter, NULL);
271 while ((ev = trace_event_iter_next(&iter)) != NULL) {
272 if (trace_event_is_vcpu(ev) &&
273 trace_event_get_state_static(ev) &&
274 trace_event_get_vcpu_state_dynamic(vcpu, ev)) {
275 /* must disable to affect the global counter */
276 trace_event_set_vcpu_state_dynamic(vcpu, ev, false);
277 }
278 }
279 }
280
281 bool trace_init_backends(void)
282 {
283 #ifdef CONFIG_TRACE_SIMPLE
284 if (!st_init()) {
285 fprintf(stderr, "failed to initialize simple tracing backend.\n");
286 return false;
287 }
288 #endif
289
290 #ifdef CONFIG_TRACE_FTRACE
291 if (!ftrace_init()) {
292 fprintf(stderr, "failed to initialize ftrace backend.\n");
293 return false;
294 }
295 #endif
296
297 #ifdef CONFIG_TRACE_SYSLOG
298 openlog(NULL, LOG_PID, LOG_DAEMON);
299 #endif
300
301 return true;
302 }
303
304 char *trace_opt_parse(const char *optarg)
305 {
306 char *trace_file;
307 QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("trace"),
308 optarg, true);
309 if (!opts) {
310 exit(1);
311 }
312 if (qemu_opt_get(opts, "enable")) {
313 trace_enable_events(qemu_opt_get(opts, "enable"));
314 }
315 trace_init_events(qemu_opt_get(opts, "events"));
316 trace_file = g_strdup(qemu_opt_get(opts, "file"));
317 qemu_opts_del(opts);
318
319 return trace_file;
320 }
321
322 uint32_t trace_get_vcpu_event_count(void)
323 {
324 return next_vcpu_id;
325 }