David 'Digit' Turner | 67c3556 | 2014-01-16 18:24:09 +0100 | [diff] [blame] | 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-common.h" |
| 21 | #include "qemu/log.h" |
| 22 | |
| 23 | static char *logfilename; |
| 24 | FILE *qemu_logfile; |
| 25 | int qemu_loglevel; |
| 26 | static int log_append = 0; |
| 27 | |
| 28 | void qemu_log(const char *fmt, ...) |
| 29 | { |
| 30 | va_list ap; |
| 31 | |
| 32 | va_start(ap, fmt); |
| 33 | if (qemu_logfile) { |
| 34 | vfprintf(qemu_logfile, fmt, ap); |
| 35 | } |
| 36 | va_end(ap); |
| 37 | } |
| 38 | |
| 39 | void qemu_log_mask(int mask, const char *fmt, ...) |
| 40 | { |
| 41 | va_list ap; |
| 42 | |
| 43 | va_start(ap, fmt); |
| 44 | if ((qemu_loglevel & mask) && qemu_logfile) { |
| 45 | vfprintf(qemu_logfile, fmt, ap); |
| 46 | } |
| 47 | va_end(ap); |
| 48 | } |
| 49 | |
| 50 | /* enable or disable low levels log */ |
| 51 | void do_qemu_set_log(int log_flags, bool use_own_buffers) |
| 52 | { |
| 53 | qemu_loglevel = log_flags; |
| 54 | if (qemu_loglevel && !qemu_logfile) { |
| 55 | if (logfilename) { |
| 56 | qemu_logfile = fopen(logfilename, log_append ? "a" : "w"); |
| 57 | if (!qemu_logfile) { |
| 58 | perror(logfilename); |
| 59 | _exit(1); |
| 60 | } |
| 61 | } else { |
| 62 | /* Default to stderr if no log file specified */ |
| 63 | qemu_logfile = stderr; |
| 64 | } |
| 65 | /* must avoid mmap() usage of glibc by setting a buffer "by hand" */ |
| 66 | if (use_own_buffers) { |
| 67 | static char logfile_buf[4096]; |
| 68 | |
| 69 | setvbuf(qemu_logfile, logfile_buf, _IOLBF, sizeof(logfile_buf)); |
| 70 | } else { |
| 71 | #if defined(_WIN32) |
| 72 | /* Win32 doesn't support line-buffering, so use unbuffered output. */ |
| 73 | setvbuf(qemu_logfile, NULL, _IONBF, 0); |
| 74 | #else |
| 75 | setvbuf(qemu_logfile, NULL, _IOLBF, 0); |
| 76 | #endif |
| 77 | log_append = 1; |
| 78 | } |
| 79 | } |
| 80 | if (!qemu_loglevel && qemu_logfile) { |
| 81 | qemu_log_close(); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | void qemu_set_log_filename(const char *filename) |
| 86 | { |
| 87 | g_free(logfilename); |
| 88 | logfilename = g_strdup(filename); |
| 89 | qemu_log_close(); |
| 90 | qemu_set_log(qemu_loglevel); |
| 91 | } |
| 92 | |
| 93 | const QEMULogItem qemu_log_items[] = { |
| 94 | { CPU_LOG_TB_OUT_ASM, "out_asm", |
| 95 | "show generated host assembly code for each compiled TB" }, |
| 96 | { CPU_LOG_TB_IN_ASM, "in_asm", |
| 97 | "show target assembly code for each compiled TB" }, |
| 98 | { CPU_LOG_TB_OP, "op", |
| 99 | "show micro ops for each compiled TB" }, |
| 100 | { CPU_LOG_TB_OP_OPT, "op_opt", |
| 101 | "show micro ops (x86 only: before eflags optimization) and\n" |
| 102 | "after liveness analysis" }, |
| 103 | { CPU_LOG_INT, "int", |
| 104 | "show interrupts/exceptions in short format" }, |
| 105 | { CPU_LOG_EXEC, "exec", |
| 106 | "show trace before each executed TB (lots of logs)" }, |
| 107 | { CPU_LOG_TB_CPU, "cpu", |
| 108 | "show CPU state before block translation" }, |
| 109 | { CPU_LOG_PCALL, "pcall", |
| 110 | "x86 only: show protected mode far calls/returns/exceptions" }, |
| 111 | { CPU_LOG_RESET, "cpu_reset", |
| 112 | "x86 only: show CPU state before CPU resets" }, |
| 113 | { CPU_LOG_IOPORT, "ioport", |
| 114 | "show all i/o ports accesses" }, |
| 115 | { LOG_UNIMP, "unimp", |
| 116 | "log unimplemented functionality" }, |
| 117 | { LOG_GUEST_ERROR, "guest_errors", |
| 118 | "log when the guest OS does something invalid (eg accessing a\n" |
| 119 | "non-existent register)" }, |
| 120 | { 0, NULL, NULL }, |
| 121 | }; |
| 122 | |
| 123 | static int cmp1(const char *s1, int n, const char *s2) |
| 124 | { |
| 125 | if (strlen(s2) != n) { |
| 126 | return 0; |
| 127 | } |
| 128 | return memcmp(s1, s2, n) == 0; |
| 129 | } |
| 130 | |
| 131 | /* takes a comma separated list of log masks. Return 0 if error. */ |
| 132 | int qemu_str_to_log_mask(const char *str) |
| 133 | { |
| 134 | const QEMULogItem *item; |
| 135 | int mask; |
| 136 | const char *p, *p1; |
| 137 | |
| 138 | p = str; |
| 139 | mask = 0; |
| 140 | for (;;) { |
| 141 | p1 = strchr(p, ','); |
| 142 | if (!p1) { |
| 143 | p1 = p + strlen(p); |
| 144 | } |
| 145 | if (cmp1(p,p1-p,"all")) { |
| 146 | for (item = qemu_log_items; item->mask != 0; item++) { |
| 147 | mask |= item->mask; |
| 148 | } |
| 149 | } else { |
| 150 | for (item = qemu_log_items; item->mask != 0; item++) { |
| 151 | if (cmp1(p, p1 - p, item->name)) { |
| 152 | goto found; |
| 153 | } |
| 154 | } |
| 155 | return 0; |
| 156 | } |
| 157 | found: |
| 158 | mask |= item->mask; |
| 159 | if (*p1 != ',') { |
| 160 | break; |
| 161 | } |
| 162 | p = p1 + 1; |
| 163 | } |
| 164 | return mask; |
| 165 | } |
| 166 | |
| 167 | void qemu_print_log_usage(FILE *f) |
| 168 | { |
| 169 | const QEMULogItem *item; |
| 170 | fprintf(f, "Log items (comma separated):\n"); |
| 171 | for (item = qemu_log_items; item->mask != 0; item++) { |
| 172 | fprintf(f, "%-10s %s\n", item->name, item->help); |
| 173 | } |
| 174 | } |