src/mesa/main/errors.c

   1 /**
   2  * \file errors.c
   3  * Mesa debugging and error handling functions.
   4  */
   5
   6 /*
   7  * Mesa 3-D graphics library
   8  *
   9  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the "Software"),
  13  * to deal in the Software without restriction, including without limitation
  14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15  * and/or sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included
  19  * in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  24  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  25  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  27  * OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29
  30
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include "errors.h"
  34 #include "enums.h"
  35 #include "imports.h"
  36 #include "context.h"
  37 #include "debug_output.h"
  38
  39
  40 static FILE *LogFile = NULL;
  41
  42
  43 static void
  44 output_if_debug(const char *prefixString, const char *outputString,
  45                 GLboolean newline)
  46 {
  47    static int debug = -1;
  48
  49    /* Init the local 'debug' var once.
  50     * Note: the _mesa_init_debug() function should have been called
  51     * by now so MESA_DEBUG_FLAGS will be initialized.
  52     */
  53    if (debug == -1) {
  54       /* If MESA_LOG_FILE env var is set, log Mesa errors, warnings,
  55        * etc to the named file.  Otherwise, output to stderr.
  56        */
  57       const char *logFile = getenv("MESA_LOG_FILE");
  58       if (logFile)
  59          LogFile = fopen(logFile, "w");
  60       if (!LogFile)
  61          LogFile = stderr;
  62 #ifdef DEBUG
  63       /* in debug builds, print messages unless MESA_DEBUG="silent" */
  64       if (MESA_DEBUG_FLAGS & DEBUG_SILENT)
  65          debug = 0;
  66       else
  67          debug = 1;
  68 #else
  69       /* in release builds, be silent unless MESA_DEBUG is set */
  70       debug = getenv("MESA_DEBUG") != NULL;
  71 #endif
  72    }
  73
  74    /* Now only print the string if we're required to do so. */
  75    if (debug) {
  76       if (prefixString)
  77          fprintf(LogFile, "%s: %s", prefixString, outputString);
  78       else
  79          fprintf(LogFile, "%s", outputString);
  80       if (newline)
  81          fprintf(LogFile, "\n");
  82       fflush(LogFile);
  83
  84 #if defined(_WIN32)
  85       /* stderr from windows applications without console is not usually
  86        * visible, so communicate with the debugger instead */
  87       {
  88          char buf[4096];
  89          _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
  90          OutputDebugStringA(buf);
  91       }
  92 #endif
  93    }
  94 }
  95
  96
  97 /**
  98  * Return the file handle to use for debug/logging.  Defaults to stderr
  99  * unless MESA_LOG_FILE is defined.
 100  */
 101 FILE *
 102 _mesa_get_log_file(void)
 103 {
 104    assert(LogFile);
 105    return LogFile;
 106 }
 107
 108
 109 /**
 110  * When a new type of error is recorded, print a message describing
 111  * previous errors which were accumulated.
 112  */
 113 static void
 114 flush_delayed_errors( struct gl_context *ctx )
 115 {
 116    char s[MAX_DEBUG_MESSAGE_LENGTH];
 117
 118    if (ctx->ErrorDebugCount) {
 119       _mesa_snprintf(s, MAX_DEBUG_MESSAGE_LENGTH, "%d similar %s errors",
 120                      ctx->ErrorDebugCount,
 121                      _mesa_enum_to_string(ctx->ErrorValue));
 122
 123       output_if_debug("Mesa", s, GL_TRUE);
 124
 125       ctx->ErrorDebugCount = 0;
 126    }
 127 }
 128
 129
 130 /**
 131  * Report a warning (a recoverable error condition) to stderr if
 132  * either DEBUG is defined or the MESA_DEBUG env var is set.
 133  *
 134  * \param ctx GL context.
 135  * \param fmtString printf()-like format string.
 136  */
 137 void
 138 _mesa_warning( struct gl_context *ctx, const char *fmtString, ... )
 139 {
 140    char str[MAX_DEBUG_MESSAGE_LENGTH];
 141    va_list args;
 142    va_start( args, fmtString );
 143    (void) _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );
 144    va_end( args );
 145
 146    if (ctx)
 147       flush_delayed_errors( ctx );
 148
 149    output_if_debug("Mesa warning", str, GL_TRUE);
 150 }
 151
 152
 153 /**
 154  * Report an internal implementation problem.
 155  * Prints the message to stderr via fprintf().
 156  *
 157  * \param ctx GL context.
 158  * \param fmtString problem description string.
 159  */
 160 void
 161 _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )
 162 {
 163    va_list args;
 164    char str[MAX_DEBUG_MESSAGE_LENGTH];
 165    static int numCalls = 0;
 166
 167    (void) ctx;
 168
 169    if (numCalls < 50) {
 170       numCalls++;
 171
 172       va_start( args, fmtString );
 173       _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );
 174       va_end( args );
 175       fprintf(stderr, "Mesa " PACKAGE_VERSION " implementation error: %s\n",
 176               str);
 177       fprintf(stderr, "Please report at " PACKAGE_BUGREPORT "\n");
 178    }
 179 }
 180
 181
 182 static GLboolean
 183 should_output(struct gl_context *ctx, GLenum error, const char *fmtString)
 184 {
 185    static GLint debug = -1;
 186
 187    /* Check debug environment variable only once:
 188     */
 189    if (debug == -1) {
 190       const char *debugEnv = getenv("MESA_DEBUG");
 191
 192 #ifdef DEBUG
 193       if (debugEnv && strstr(debugEnv, "silent"))
 194          debug = GL_FALSE;
 195       else
 196          debug = GL_TRUE;
 197 #else
 198       if (debugEnv)
 199          debug = GL_TRUE;
 200       else
 201          debug = GL_FALSE;
 202 #endif
 203    }
 204
 205    if (debug) {
 206       if (ctx->ErrorValue != error ||
 207           ctx->ErrorDebugFmtString != fmtString) {
 208          flush_delayed_errors( ctx );
 209          ctx->ErrorDebugFmtString = fmtString;
 210          ctx->ErrorDebugCount = 0;
 211          return GL_TRUE;
 212       }
 213       ctx->ErrorDebugCount++;
 214    }
 215    return GL_FALSE;
 216 }
 217
 218
 219 void
 220 _mesa_gl_vdebug(struct gl_context *ctx,
 221                 GLuint *id,
 222                 enum mesa_debug_source source,
 223                 enum mesa_debug_type type,
 224                 enum mesa_debug_severity severity,
 225                 const char *fmtString,
 226                 va_list args)
 227 {
 228    char s[MAX_DEBUG_MESSAGE_LENGTH];
 229    int len;
 230
 231    _mesa_debug_get_id(id);
 232
 233    len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
 234    if (len >= MAX_DEBUG_MESSAGE_LENGTH)
 235       /* message was truncated */
 236       len = MAX_DEBUG_MESSAGE_LENGTH - 1;
 237
 238    _mesa_log_msg(ctx, source, type, *id, severity, len, s);
 239 }
 240
 241
 242 void
 243 _mesa_gl_debug(struct gl_context *ctx,
 244                GLuint *id,
 245                enum mesa_debug_source source,
 246                enum mesa_debug_type type,
 247                enum mesa_debug_severity severity,
 248                const char *fmtString, ...)
 249 {
 250    va_list args;
 251    va_start(args, fmtString);
 252    _mesa_gl_vdebug(ctx, id, source, type, severity, fmtString, args);
 253    va_end(args);
 254 }
 255
 256
 257 /**
 258  * Record an OpenGL state error.  These usually occur when the user
 259  * passes invalid parameters to a GL function.
 260  *
 261  * If debugging is enabled (either at compile-time via the DEBUG macro, or
 262  * run-time via the MESA_DEBUG environment variable), report the error with
 263  * _mesa_debug().
 264  *
 265  * \param ctx the GL context.
 266  * \param error the error value.
 267  * \param fmtString printf() style format string, followed by optional args
 268  */
 269 void
 270 _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
 271 {
 272    GLboolean do_output, do_log;
 273    /* Ideally this would be set up by the caller, so that we had proper IDs
 274     * per different message.
 275     */
 276    static GLuint error_msg_id = 0;
 277
 278    _mesa_debug_get_id(&error_msg_id);
 279
 280    do_output = should_output(ctx, error, fmtString);
 281
 282    simple_mtx_lock(&ctx->DebugMutex);
 283    if (ctx->Debug) {
 284       do_log = _mesa_debug_is_message_enabled(ctx->Debug,
 285                                               MESA_DEBUG_SOURCE_API,
 286                                               MESA_DEBUG_TYPE_ERROR,
 287                                               error_msg_id,
 288                                               MESA_DEBUG_SEVERITY_HIGH);
 289    }
 290    else {
 291       do_log = GL_FALSE;
 292    }
 293    simple_mtx_unlock(&ctx->DebugMutex);
 294
 295    if (do_output || do_log) {
 296       char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH];
 297       int len;
 298       va_list args;
 299
 300       va_start(args, fmtString);
 301       len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
 302       va_end(args);
 303
 304       if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
 305          /* Too long error message. Whoever calls _mesa_error should use
 306           * shorter strings.
 307           */
 308          assert(0);
 309          return;
 310       }
 311
 312       len = _mesa_snprintf(s2, MAX_DEBUG_MESSAGE_LENGTH, "%s in %s",
 313                            _mesa_enum_to_string(error), s);
 314       if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
 315          /* Same as above. */
 316          assert(0);
 317          return;
 318       }
 319
 320       /* Print the error to stderr if needed. */
 321       if (do_output) {
 322          output_if_debug("Mesa: User error", s2, GL_TRUE);
 323       }
 324
 325       /* Log the error via ARB_debug_output if needed.*/
 326       if (do_log) {
 327          _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, MESA_DEBUG_TYPE_ERROR,
 328                        error_msg_id, MESA_DEBUG_SEVERITY_HIGH, len, s2);
 329       }
 330    }
 331
 332    /* Set the GL context error state for glGetError. */
 333    if (ctx->ErrorValue == GL_NO_ERROR)
 334       ctx->ErrorValue = error;
 335 }
 336
 337 void
 338 _mesa_error_no_memory(const char *caller)
 339 {
 340    GET_CURRENT_CONTEXT(ctx);
 341    _mesa_error(ctx, GL_OUT_OF_MEMORY, "out of memory in %s", caller);
 342 }
 343
 344 /**
 345  * Report debug information.  Print error message to stderr via fprintf().
 346  * No-op if DEBUG mode not enabled.
 347  *
 348  * \param ctx GL context.
 349  * \param fmtString printf()-style format string, followed by optional args.
 350  */
 351 void
 352 _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... )
 353 {
 354 #ifdef DEBUG
 355    char s[MAX_DEBUG_MESSAGE_LENGTH];
 356    va_list args;
 357    va_start(args, fmtString);
 358    _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
 359    va_end(args);
 360    output_if_debug("Mesa", s, GL_FALSE);
 361 #endif /* DEBUG */
 362    (void) ctx;
 363    (void) fmtString;
 364 }
 365
 366
 367 void
 368 _mesa_log(const char *fmtString, ...)
 369 {
 370    char s[MAX_DEBUG_MESSAGE_LENGTH];
 371    va_list args;
 372    va_start(args, fmtString);
 373    _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
 374    va_end(args);
 375    output_if_debug("", s, GL_FALSE);
 376 }
 377
 378
 379 /**
 380  * Report debug information from the shader compiler via GL_ARB_debug_output.
 381  *
 382  * \param ctx GL context.
 383  * \param type The namespace to which this message belongs.
 384  * \param id The message ID within the given namespace.
 385  * \param msg The message to output. Must be null-terminated.
 386  */
 387 void
 388 _mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
 389                    const char *msg)
 390 {
 391    enum mesa_debug_source source = MESA_DEBUG_SOURCE_SHADER_COMPILER;
 392    enum mesa_debug_severity severity = MESA_DEBUG_SEVERITY_HIGH;
 393    int len;
 394
 395    _mesa_debug_get_id(id);
 396
 397    len = strlen(msg);
 398
 399    /* Truncate the message if necessary. */
 400    if (len >= MAX_DEBUG_MESSAGE_LENGTH)
 401       len = MAX_DEBUG_MESSAGE_LENGTH - 1;
 402
 403    _mesa_log_msg(ctx, source, type, *id, severity, len, msg);
 404 }