1 /* 2 * Error reporting 3 * 4 * Copyright (C) 2010 Red Hat Inc. 5 * 6 * Authors: 7 * Markus Armbruster <armbru@redhat.com>, 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or later. 10 * See the COPYING file in the top-level directory. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "monitor/monitor.h" 15 #include "qemu/error-report.h" 16 17 /* 18 * @report_type is the type of message: error, warning or 19 * informational. 20 */ 21 typedef enum { 22 REPORT_TYPE_ERROR, 23 REPORT_TYPE_WARNING, 24 REPORT_TYPE_INFO, 25 } report_type; 26 27 /* Prepend timestamp to messages */ 28 bool message_with_timestamp; 29 bool error_with_guestname; 30 const char *error_guest_name; 31 32 int error_printf(const char *fmt, ...) 33 { 34 va_list ap; 35 int ret; 36 37 va_start(ap, fmt); 38 ret = error_vprintf(fmt, ap); 39 va_end(ap); 40 return ret; 41 } 42 43 static Location std_loc = { 44 .kind = LOC_NONE 45 }; 46 static Location *cur_loc = &std_loc; 47 48 /* 49 * Push location saved in LOC onto the location stack, return it. 50 * The top of that stack is the current location. 51 * Needs a matching loc_pop(). 52 */ 53 Location *loc_push_restore(Location *loc) 54 { 55 assert(!loc->prev); 56 loc->prev = cur_loc; 57 cur_loc = loc; 58 return loc; 59 } 60 61 /* 62 * Initialize *LOC to "nowhere", push it onto the location stack. 63 * The top of that stack is the current location. 64 * Needs a matching loc_pop(). 65 * Return LOC. 66 */ 67 Location *loc_push_none(Location *loc) 68 { 69 loc->kind = LOC_NONE; 70 loc->prev = NULL; 71 return loc_push_restore(loc); 72 } 73 74 /* 75 * Pop the location stack. 76 * LOC must be the current location, i.e. the top of the stack. 77 */ 78 Location *loc_pop(Location *loc) 79 { 80 assert(cur_loc == loc && loc->prev); 81 cur_loc = loc->prev; 82 loc->prev = NULL; 83 return loc; 84 } 85 86 /* 87 * Save the current location in LOC, return LOC. 88 */ 89 Location *loc_save(Location *loc) 90 { 91 *loc = *cur_loc; 92 loc->prev = NULL; 93 return loc; 94 } 95 96 /* 97 * Change the current location to the one saved in LOC. 98 */ 99 void loc_restore(Location *loc) 100 { 101 Location *prev = cur_loc->prev; 102 assert(!loc->prev); 103 *cur_loc = *loc; 104 cur_loc->prev = prev; 105 } 106 107 /* 108 * Change the current location to "nowhere in particular". 109 */ 110 void loc_set_none(void) 111 { 112 cur_loc->kind = LOC_NONE; 113 } 114 115 /* 116 * Change the current location to argument ARGV[IDX..IDX+CNT-1]. 117 */ 118 void loc_set_cmdline(char **argv, int idx, int cnt) 119 { 120 cur_loc->kind = LOC_CMDLINE; 121 cur_loc->num = cnt; 122 cur_loc->ptr = argv + idx; 123 } 124 125 /* 126 * Change the current location to file FNAME, line LNO. 127 */ 128 void loc_set_file(const char *fname, int lno) 129 { 130 assert (fname || cur_loc->kind == LOC_FILE); 131 cur_loc->kind = LOC_FILE; 132 cur_loc->num = lno; 133 if (fname) { 134 cur_loc->ptr = fname; 135 } 136 } 137 138 /* 139 * Print current location to current monitor if we have one, else to stderr. 140 */ 141 static void print_loc(void) 142 { 143 const char *sep = ""; 144 int i; 145 const char *const *argp; 146 147 if (!monitor_cur() && g_get_prgname()) { 148 error_printf("%s:", g_get_prgname()); 149 sep = " "; 150 } 151 switch (cur_loc->kind) { 152 case LOC_CMDLINE: 153 argp = cur_loc->ptr; 154 for (i = 0; i < cur_loc->num; i++) { 155 error_printf("%s%s", sep, argp[i]); 156 sep = " "; 157 } 158 error_printf(": "); 159 break; 160 case LOC_FILE: 161 error_printf("%s:", (const char *)cur_loc->ptr); 162 if (cur_loc->num) { 163 error_printf("%d:", cur_loc->num); 164 } 165 error_printf(" "); 166 break; 167 default: 168 error_printf("%s", sep); 169 } 170 } 171 172 static char * 173 real_time_iso8601(void) 174 { 175 #if GLIB_CHECK_VERSION(2,62,0) 176 g_autoptr(GDateTime) dt = g_date_time_new_from_unix_utc(g_get_real_time()); 177 /* ignore deprecation warning, since GLIB_VERSION_MAX_ALLOWED is 2.56 */ 178 #pragma GCC diagnostic push 179 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 180 return g_date_time_format_iso8601(dt); 181 #pragma GCC diagnostic pop 182 #else 183 GTimeVal tv; 184 g_get_current_time(&tv); 185 return g_time_val_to_iso8601(&tv); 186 #endif 187 } 188 189 /* 190 * Print a message to current monitor if we have one, else to stderr. 191 * @report_type is the type of message: error, warning or informational. 192 * Format arguments like vsprintf(). The resulting message should be 193 * a single phrase, with no newline or trailing punctuation. 194 * Prepend the current location and append a newline. 195 */ 196 static void vreport(report_type type, const char *fmt, va_list ap) 197 { 198 gchar *timestr; 199 200 if (message_with_timestamp && !monitor_cur()) { 201 timestr = real_time_iso8601(); 202 error_printf("%s ", timestr); 203 g_free(timestr); 204 } 205 206 /* Only prepend guest name if -msg guest-name and -name guest=... are set */ 207 if (error_with_guestname && error_guest_name && !monitor_cur()) { 208 error_printf("%s ", error_guest_name); 209 } 210 211 print_loc(); 212 213 switch (type) { 214 case REPORT_TYPE_ERROR: 215 break; 216 case REPORT_TYPE_WARNING: 217 error_printf("warning: "); 218 break; 219 case REPORT_TYPE_INFO: 220 error_printf("info: "); 221 break; 222 } 223 224 error_vprintf(fmt, ap); 225 error_printf("\n"); 226 } 227 228 /* 229 * Print an error message to current monitor if we have one, else to stderr. 230 * Format arguments like vsprintf(). The resulting message should be 231 * a single phrase, with no newline or trailing punctuation. 232 * Prepend the current location and append a newline. 233 * It's wrong to call this in a QMP monitor. Use error_setg() there. 234 */ 235 void error_vreport(const char *fmt, va_list ap) 236 { 237 vreport(REPORT_TYPE_ERROR, fmt, ap); 238 } 239 240 /* 241 * Print a warning message to current monitor if we have one, else to stderr. 242 * Format arguments like vsprintf(). The resulting message should be 243 * a single phrase, with no newline or trailing punctuation. 244 * Prepend the current location and append a newline. 245 */ 246 void warn_vreport(const char *fmt, va_list ap) 247 { 248 vreport(REPORT_TYPE_WARNING, fmt, ap); 249 } 250 251 /* 252 * Print an information message to current monitor if we have one, else to 253 * stderr. 254 * Format arguments like vsprintf(). The resulting message should be 255 * a single phrase, with no newline or trailing punctuation. 256 * Prepend the current location and append a newline. 257 */ 258 void info_vreport(const char *fmt, va_list ap) 259 { 260 vreport(REPORT_TYPE_INFO, fmt, ap); 261 } 262 263 /* 264 * Print an error message to current monitor if we have one, else to stderr. 265 * Format arguments like sprintf(). The resulting message should be 266 * a single phrase, with no newline or trailing punctuation. 267 * Prepend the current location and append a newline. 268 * It's wrong to call this in a QMP monitor. Use error_setg() there. 269 */ 270 void error_report(const char *fmt, ...) 271 { 272 va_list ap; 273 274 va_start(ap, fmt); 275 vreport(REPORT_TYPE_ERROR, fmt, ap); 276 va_end(ap); 277 } 278 279 /* 280 * Print a warning message to current monitor if we have one, else to stderr. 281 * Format arguments like sprintf(). The resulting message should be a 282 * single phrase, with no newline or trailing punctuation. 283 * Prepend the current location and append a newline. 284 */ 285 void warn_report(const char *fmt, ...) 286 { 287 va_list ap; 288 289 va_start(ap, fmt); 290 vreport(REPORT_TYPE_WARNING, fmt, ap); 291 va_end(ap); 292 } 293 294 /* 295 * Print an information message to current monitor if we have one, else to 296 * stderr. 297 * Format arguments like sprintf(). The resulting message should be a 298 * single phrase, with no newline or trailing punctuation. 299 * Prepend the current location and append a newline. 300 */ 301 void info_report(const char *fmt, ...) 302 { 303 va_list ap; 304 305 va_start(ap, fmt); 306 vreport(REPORT_TYPE_INFO, fmt, ap); 307 va_end(ap); 308 } 309 310 /* 311 * Like error_report(), except print just once. 312 * If *printed is false, print the message, and flip *printed to true. 313 * Return whether the message was printed. 314 */ 315 bool error_report_once_cond(bool *printed, const char *fmt, ...) 316 { 317 va_list ap; 318 319 assert(printed); 320 if (*printed) { 321 return false; 322 } 323 *printed = true; 324 va_start(ap, fmt); 325 vreport(REPORT_TYPE_ERROR, fmt, ap); 326 va_end(ap); 327 return true; 328 } 329 330 /* 331 * Like warn_report(), except print just once. 332 * If *printed is false, print the message, and flip *printed to true. 333 * Return whether the message was printed. 334 */ 335 bool warn_report_once_cond(bool *printed, const char *fmt, ...) 336 { 337 va_list ap; 338 339 assert(printed); 340 if (*printed) { 341 return false; 342 } 343 *printed = true; 344 va_start(ap, fmt); 345 vreport(REPORT_TYPE_WARNING, fmt, ap); 346 va_end(ap); 347 return true; 348 } 349 350 static char *qemu_glog_domains; 351 352 static void qemu_log_func(const gchar *log_domain, 353 GLogLevelFlags log_level, 354 const gchar *message, 355 gpointer user_data) 356 { 357 switch (log_level & G_LOG_LEVEL_MASK) { 358 case G_LOG_LEVEL_DEBUG: 359 case G_LOG_LEVEL_INFO: 360 /* 361 * Use same G_MESSAGES_DEBUG logic as glib to enable/disable debug 362 * messages 363 */ 364 if (qemu_glog_domains == NULL) { 365 break; 366 } 367 if (strcmp(qemu_glog_domains, "all") != 0 && 368 (log_domain == NULL || !strstr(qemu_glog_domains, log_domain))) { 369 break; 370 } 371 /* Fall through */ 372 case G_LOG_LEVEL_MESSAGE: 373 info_report("%s%s%s", 374 log_domain ?: "", log_domain ? ": " : "", message); 375 376 break; 377 case G_LOG_LEVEL_WARNING: 378 warn_report("%s%s%s", 379 log_domain ?: "", log_domain ? ": " : "", message); 380 break; 381 case G_LOG_LEVEL_CRITICAL: 382 case G_LOG_LEVEL_ERROR: 383 error_report("%s%s%s", 384 log_domain ?: "", log_domain ? ": " : "", message); 385 break; 386 } 387 } 388 389 void error_init(const char *argv0) 390 { 391 const char *p = strrchr(argv0, '/'); 392 393 /* Set the program name for error_print_loc(). */ 394 g_set_prgname(p ? p + 1 : argv0); 395 396 /* 397 * This sets up glib logging so libraries using it also print their logs 398 * through error_report(), warn_report(), info_report(). 399 */ 400 g_log_set_default_handler(qemu_log_func, NULL); 401 g_warn_if_fail(qemu_glog_domains == NULL); 402 qemu_glog_domains = g_strdup(g_getenv("G_MESSAGES_DEBUG")); 403 } 404