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 #ifdef CONFIG_PLUGIN 277 { CPU_LOG_PLUGIN, "plugin", "output from TCG plugins\n"}, 278 #endif 279 { 0, NULL, NULL }, 280 }; 281 282 /* takes a comma separated list of log masks. Return 0 if error. */ 283 int qemu_str_to_log_mask(const char *str) 284 { 285 const QEMULogItem *item; 286 int mask = 0; 287 char **parts = g_strsplit(str, ",", 0); 288 char **tmp; 289 290 for (tmp = parts; tmp && *tmp; tmp++) { 291 if (g_str_equal(*tmp, "all")) { 292 for (item = qemu_log_items; item->mask != 0; item++) { 293 mask |= item->mask; 294 } 295 #ifdef CONFIG_TRACE_LOG 296 } else if (g_str_has_prefix(*tmp, "trace:") && (*tmp)[6] != '\0') { 297 trace_enable_events((*tmp) + 6); 298 mask |= LOG_TRACE; 299 #endif 300 } else { 301 for (item = qemu_log_items; item->mask != 0; item++) { 302 if (g_str_equal(*tmp, item->name)) { 303 goto found; 304 } 305 } 306 goto error; 307 found: 308 mask |= item->mask; 309 } 310 } 311 312 g_strfreev(parts); 313 return mask; 314 315 error: 316 g_strfreev(parts); 317 return 0; 318 } 319 320 void qemu_print_log_usage(FILE *f) 321 { 322 const QEMULogItem *item; 323 fprintf(f, "Log items (comma separated):\n"); 324 for (item = qemu_log_items; item->mask != 0; item++) { 325 fprintf(f, "%-15s %s\n", item->name, item->help); 326 } 327 #ifdef CONFIG_TRACE_LOG 328 fprintf(f, "trace:PATTERN enable trace events\n"); 329 fprintf(f, "\nUse \"-d trace:help\" to get a list of trace events.\n\n"); 330 #endif 331 } 332