1 | /* |
2 | * Logging support |
3 | * |
4 | * Copyright (c) 2003 Fabrice Bellard |
5 | * |
6 | * This library is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2 of the License, or (at your option) any later version. |
10 | * |
11 | * This library is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
18 | */ |
19 | |
20 | #include "qemu/osdep.h" |
21 | #include "qemu/log.h" |
22 | #include "qemu/range.h" |
23 | #include "qemu/error-report.h" |
24 | #include "qapi/error.h" |
25 | #include "qemu/cutils.h" |
26 | #include "trace/control.h" |
27 | |
28 | static char *logfilename; |
29 | FILE *qemu_logfile; |
30 | int qemu_loglevel; |
31 | static int log_append = 0; |
32 | static GArray *debug_regions; |
33 | |
34 | /* Return the number of characters emitted. */ |
35 | int qemu_log(const char *fmt, ...) |
36 | { |
37 | int ret = 0; |
38 | if (qemu_logfile) { |
39 | va_list ap; |
40 | va_start(ap, fmt); |
41 | ret = vfprintf(qemu_logfile, fmt, ap); |
42 | va_end(ap); |
43 | |
44 | /* Don't pass back error results. */ |
45 | if (ret < 0) { |
46 | ret = 0; |
47 | } |
48 | } |
49 | return ret; |
50 | } |
51 | |
52 | static bool log_uses_own_buffers; |
53 | |
54 | /* enable or disable low levels log */ |
55 | void qemu_set_log(int log_flags) |
56 | { |
57 | qemu_loglevel = log_flags; |
58 | #ifdef CONFIG_TRACE_LOG |
59 | qemu_loglevel |= LOG_TRACE; |
60 | #endif |
61 | if (!qemu_logfile && |
62 | (is_daemonized() ? logfilename != NULL : qemu_loglevel)) { |
63 | if (logfilename) { |
64 | qemu_logfile = fopen(logfilename, log_append ? "a" : "w" ); |
65 | if (!qemu_logfile) { |
66 | perror(logfilename); |
67 | _exit(1); |
68 | } |
69 | /* In case we are a daemon redirect stderr to logfile */ |
70 | if (is_daemonized()) { |
71 | dup2(fileno(qemu_logfile), STDERR_FILENO); |
72 | fclose(qemu_logfile); |
73 | /* This will skip closing logfile in qemu_log_close() */ |
74 | qemu_logfile = stderr; |
75 | } |
76 | } else { |
77 | /* Default to stderr if no log file specified */ |
78 | assert(!is_daemonized()); |
79 | qemu_logfile = stderr; |
80 | } |
81 | /* must avoid mmap() usage of glibc by setting a buffer "by hand" */ |
82 | if (log_uses_own_buffers) { |
83 | static char logfile_buf[4096]; |
84 | |
85 | setvbuf(qemu_logfile, logfile_buf, _IOLBF, sizeof(logfile_buf)); |
86 | } else { |
87 | #if defined(_WIN32) |
88 | /* Win32 doesn't support line-buffering, so use unbuffered output. */ |
89 | setvbuf(qemu_logfile, NULL, _IONBF, 0); |
90 | #else |
91 | setvbuf(qemu_logfile, NULL, _IOLBF, 0); |
92 | #endif |
93 | log_append = 1; |
94 | } |
95 | } |
96 | if (qemu_logfile && |
97 | (is_daemonized() ? logfilename == NULL : !qemu_loglevel)) { |
98 | qemu_log_close(); |
99 | } |
100 | } |
101 | |
102 | void qemu_log_needs_buffers(void) |
103 | { |
104 | log_uses_own_buffers = true; |
105 | } |
106 | |
107 | /* |
108 | * Allow the user to include %d in their logfile which will be |
109 | * substituted with the current PID. This is useful for debugging many |
110 | * nested linux-user tasks but will result in lots of logs. |
111 | */ |
112 | void qemu_set_log_filename(const char *filename, Error **errp) |
113 | { |
114 | char *pidstr; |
115 | g_free(logfilename); |
116 | |
117 | pidstr = strstr(filename, "%" ); |
118 | if (pidstr) { |
119 | /* We only accept one %d, no other format strings */ |
120 | if (pidstr[1] != 'd' || strchr(pidstr + 2, '%')) { |
121 | error_setg(errp, "Bad logfile format: %s" , filename); |
122 | return; |
123 | } else { |
124 | logfilename = g_strdup_printf(filename, getpid()); |
125 | } |
126 | } else { |
127 | logfilename = g_strdup(filename); |
128 | } |
129 | qemu_log_close(); |
130 | qemu_set_log(qemu_loglevel); |
131 | } |
132 | |
133 | /* Returns true if addr is in our debug filter or no filter defined |
134 | */ |
135 | bool qemu_log_in_addr_range(uint64_t addr) |
136 | { |
137 | if (debug_regions) { |
138 | int i = 0; |
139 | for (i = 0; i < debug_regions->len; i++) { |
140 | Range *range = &g_array_index(debug_regions, Range, i); |
141 | if (range_contains(range, addr)) { |
142 | return true; |
143 | } |
144 | } |
145 | return false; |
146 | } else { |
147 | return true; |
148 | } |
149 | } |
150 | |
151 | |
152 | void qemu_set_dfilter_ranges(const char *filter_spec, Error **errp) |
153 | { |
154 | gchar **ranges = g_strsplit(filter_spec, "," , 0); |
155 | int i; |
156 | |
157 | if (debug_regions) { |
158 | g_array_unref(debug_regions); |
159 | debug_regions = NULL; |
160 | } |
161 | |
162 | debug_regions = g_array_sized_new(FALSE, FALSE, |
163 | sizeof(Range), g_strv_length(ranges)); |
164 | for (i = 0; ranges[i]; i++) { |
165 | const char *r = ranges[i]; |
166 | const char *range_op, *r2, *e; |
167 | uint64_t r1val, r2val, lob, upb; |
168 | struct Range range; |
169 | |
170 | range_op = strstr(r, "-" ); |
171 | r2 = range_op ? range_op + 1 : NULL; |
172 | if (!range_op) { |
173 | range_op = strstr(r, "+" ); |
174 | r2 = range_op ? range_op + 1 : NULL; |
175 | } |
176 | if (!range_op) { |
177 | range_op = strstr(r, ".." ); |
178 | r2 = range_op ? range_op + 2 : NULL; |
179 | } |
180 | if (!range_op) { |
181 | error_setg(errp, "Bad range specifier" ); |
182 | goto out; |
183 | } |
184 | |
185 | if (qemu_strtou64(r, &e, 0, &r1val) |
186 | || e != range_op) { |
187 | error_setg(errp, "Invalid number to the left of %.*s" , |
188 | (int)(r2 - range_op), range_op); |
189 | goto out; |
190 | } |
191 | if (qemu_strtou64(r2, NULL, 0, &r2val)) { |
192 | error_setg(errp, "Invalid number to the right of %.*s" , |
193 | (int)(r2 - range_op), range_op); |
194 | goto out; |
195 | } |
196 | |
197 | switch (*range_op) { |
198 | case '+': |
199 | lob = r1val; |
200 | upb = r1val + r2val - 1; |
201 | break; |
202 | case '-': |
203 | upb = r1val; |
204 | lob = r1val - (r2val - 1); |
205 | break; |
206 | case '.': |
207 | lob = r1val; |
208 | upb = r2val; |
209 | break; |
210 | default: |
211 | g_assert_not_reached(); |
212 | } |
213 | if (lob > upb) { |
214 | error_setg(errp, "Invalid range" ); |
215 | goto out; |
216 | } |
217 | range_set_bounds(&range, lob, upb); |
218 | g_array_append_val(debug_regions, range); |
219 | } |
220 | out: |
221 | g_strfreev(ranges); |
222 | } |
223 | |
224 | /* fflush() the log file */ |
225 | void qemu_log_flush(void) |
226 | { |
227 | fflush(qemu_logfile); |
228 | } |
229 | |
230 | /* Close the log file */ |
231 | void qemu_log_close(void) |
232 | { |
233 | if (qemu_logfile) { |
234 | if (qemu_logfile != stderr) { |
235 | fclose(qemu_logfile); |
236 | } |
237 | qemu_logfile = NULL; |
238 | } |
239 | } |
240 | |
241 | const QEMULogItem qemu_log_items[] = { |
242 | { CPU_LOG_TB_OUT_ASM, "out_asm" , |
243 | "show generated host assembly code for each compiled TB" }, |
244 | { CPU_LOG_TB_IN_ASM, "in_asm" , |
245 | "show target assembly code for each compiled TB" }, |
246 | { CPU_LOG_TB_OP, "op" , |
247 | "show micro ops for each compiled TB" }, |
248 | { CPU_LOG_TB_OP_OPT, "op_opt" , |
249 | "show micro ops after optimization" }, |
250 | { CPU_LOG_TB_OP_IND, "op_ind" , |
251 | "show micro ops before indirect lowering" }, |
252 | { CPU_LOG_INT, "int" , |
253 | "show interrupts/exceptions in short format" }, |
254 | { CPU_LOG_EXEC, "exec" , |
255 | "show trace before each executed TB (lots of logs)" }, |
256 | { CPU_LOG_TB_CPU, "cpu" , |
257 | "show CPU registers before entering a TB (lots of logs)" }, |
258 | { CPU_LOG_TB_FPU, "fpu" , |
259 | "include FPU registers in the 'cpu' logging" }, |
260 | { CPU_LOG_MMU, "mmu" , |
261 | "log MMU-related activities" }, |
262 | { CPU_LOG_PCALL, "pcall" , |
263 | "x86 only: show protected mode far calls/returns/exceptions" }, |
264 | { CPU_LOG_RESET, "cpu_reset" , |
265 | "show CPU state before CPU resets" }, |
266 | { LOG_UNIMP, "unimp" , |
267 | "log unimplemented functionality" }, |
268 | { LOG_GUEST_ERROR, "guest_errors" , |
269 | "log when the guest OS does something invalid (eg accessing a\n" |
270 | "non-existent register)" }, |
271 | { CPU_LOG_PAGE, "page" , |
272 | "dump pages at beginning of user mode emulation" }, |
273 | { CPU_LOG_TB_NOCHAIN, "nochain" , |
274 | "do not chain compiled TBs so that \"exec\" and \"cpu\" show\n" |
275 | "complete traces" }, |
276 | { 0, NULL, NULL }, |
277 | }; |
278 | |
279 | /* takes a comma separated list of log masks. Return 0 if error. */ |
280 | int qemu_str_to_log_mask(const char *str) |
281 | { |
282 | const QEMULogItem *item; |
283 | int mask = 0; |
284 | char **parts = g_strsplit(str, "," , 0); |
285 | char **tmp; |
286 | |
287 | for (tmp = parts; tmp && *tmp; tmp++) { |
288 | if (g_str_equal(*tmp, "all" )) { |
289 | for (item = qemu_log_items; item->mask != 0; item++) { |
290 | mask |= item->mask; |
291 | } |
292 | #ifdef CONFIG_TRACE_LOG |
293 | } else if (g_str_has_prefix(*tmp, "trace:" ) && (*tmp)[6] != '\0') { |
294 | trace_enable_events((*tmp) + 6); |
295 | mask |= LOG_TRACE; |
296 | #endif |
297 | } else { |
298 | for (item = qemu_log_items; item->mask != 0; item++) { |
299 | if (g_str_equal(*tmp, item->name)) { |
300 | goto found; |
301 | } |
302 | } |
303 | goto error; |
304 | found: |
305 | mask |= item->mask; |
306 | } |
307 | } |
308 | |
309 | g_strfreev(parts); |
310 | return mask; |
311 | |
312 | error: |
313 | g_strfreev(parts); |
314 | return 0; |
315 | } |
316 | |
317 | void qemu_print_log_usage(FILE *f) |
318 | { |
319 | const QEMULogItem *item; |
320 | fprintf(f, "Log items (comma separated):\n" ); |
321 | for (item = qemu_log_items; item->mask != 0; item++) { |
322 | fprintf(f, "%-15s %s\n" , item->name, item->help); |
323 | } |
324 | #ifdef CONFIG_TRACE_LOG |
325 | fprintf(f, "trace:PATTERN enable trace events\n" ); |
326 | fprintf(f, "\nUse \"-d trace:help\" to get a list of trace events.\n\n" ); |
327 | #endif |
328 | } |
329 | |