xref: /qemu/trace/control.c (revision bc5c4f21) 
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 }
326