src/mesa/main/debug_output.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2016  Brian Paul, et al   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include "context.h"
  29 #include "debug_output.h"
  30 #include "enums.h"
  31 #include "imports.h"
  32 #include "hash.h"
  33 #include "mtypes.h"
  34 #include "version.h"
  35 #include "util/hash_table.h"
  36 #include "util/simple_list.h"
  37
  38
  39 static simple_mtx_t DynamicIDMutex = _SIMPLE_MTX_INITIALIZER_NP;
  40 static GLuint NextDynamicID = 1;
  41
  42
  43 /**
  44  * A namespace element.
  45  */
  46 struct gl_debug_element
  47 {
  48    struct simple_node link;
  49
  50    GLuint ID;
  51    /* at which severity levels (mesa_debug_severity) is the message enabled */
  52    GLbitfield State;
  53 };
  54
  55
  56 struct gl_debug_namespace
  57 {
  58    struct simple_node Elements;
  59    GLbitfield DefaultState;
  60 };
  61
  62
  63 struct gl_debug_group {
  64    struct gl_debug_namespace Namespaces[MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT];
  65 };
  66
  67
  68 /**
  69  * An error, warning, or other piece of debug information for an application
  70  * to consume via GL_ARB_debug_output/GL_KHR_debug.
  71  */
  72 struct gl_debug_message
  73 {
  74    enum mesa_debug_source source;
  75    enum mesa_debug_type type;
  76    GLuint id;
  77    enum mesa_debug_severity severity;
  78    /* length as given by the user - if message was explicitly null terminated,
  79     * length can be negative */
  80    GLsizei length;
  81    GLcharARB *message;
  82 };
  83
  84
  85 /**
  86  * Debug message log.  It works like a ring buffer.
  87  */
  88 struct gl_debug_log {
  89    struct gl_debug_message Messages[MAX_DEBUG_LOGGED_MESSAGES];
  90    GLint NextMessage;
  91    GLint NumMessages;
  92 };
  93
  94
  95 struct gl_debug_state
  96 {
  97    GLDEBUGPROC Callback;
  98    const void *CallbackData;
  99    GLboolean SyncOutput;
 100    GLboolean DebugOutput;
 101    GLboolean LogToStderr;
 102
 103    struct gl_debug_group *Groups[MAX_DEBUG_GROUP_STACK_DEPTH];
 104    struct gl_debug_message GroupMessages[MAX_DEBUG_GROUP_STACK_DEPTH];
 105    GLint CurrentGroup; // GroupStackDepth - 1
 106
 107    struct gl_debug_log Log;
 108 };
 109
 110
 111 static char out_of_memory[] = "Debugging error: out of memory";
 112
 113 static const GLenum debug_source_enums[] = {
 114    GL_DEBUG_SOURCE_API,
 115    GL_DEBUG_SOURCE_WINDOW_SYSTEM,
 116    GL_DEBUG_SOURCE_SHADER_COMPILER,
 117    GL_DEBUG_SOURCE_THIRD_PARTY,
 118    GL_DEBUG_SOURCE_APPLICATION,
 119    GL_DEBUG_SOURCE_OTHER,
 120 };
 121
 122 static const GLenum debug_type_enums[] = {
 123    GL_DEBUG_TYPE_ERROR,
 124    GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR,
 125    GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR,
 126    GL_DEBUG_TYPE_PORTABILITY,
 127    GL_DEBUG_TYPE_PERFORMANCE,
 128    GL_DEBUG_TYPE_OTHER,
 129    GL_DEBUG_TYPE_MARKER,
 130    GL_DEBUG_TYPE_PUSH_GROUP,
 131    GL_DEBUG_TYPE_POP_GROUP,
 132 };
 133
 134 static const GLenum debug_severity_enums[] = {
 135    GL_DEBUG_SEVERITY_LOW,
 136    GL_DEBUG_SEVERITY_MEDIUM,
 137    GL_DEBUG_SEVERITY_HIGH,
 138    GL_DEBUG_SEVERITY_NOTIFICATION,
 139 };
 140
 141
 142 static enum mesa_debug_source
 143 gl_enum_to_debug_source(GLenum e)
 144 {
 145    unsigned i;
 146
 147    for (i = 0; i < ARRAY_SIZE(debug_source_enums); i++) {
 148       if (debug_source_enums[i] == e)
 149          break;
 150    }
 151    return i;
 152 }
 153
 154 static enum mesa_debug_type
 155 gl_enum_to_debug_type(GLenum e)
 156 {
 157    unsigned i;
 158
 159    for (i = 0; i < ARRAY_SIZE(debug_type_enums); i++) {
 160       if (debug_type_enums[i] == e)
 161          break;
 162    }
 163    return i;
 164 }
 165
 166 static enum mesa_debug_severity
 167 gl_enum_to_debug_severity(GLenum e)
 168 {
 169    unsigned i;
 170
 171    for (i = 0; i < ARRAY_SIZE(debug_severity_enums); i++) {
 172       if (debug_severity_enums[i] == e)
 173          break;
 174    }
 175    return i;
 176 }
 177
 178
 179 /**
 180  * Handles generating a GL_ARB_debug_output message ID generated by the GL or
 181  * GLSL compiler.
 182  *
 183  * The GL API has this "ID" mechanism, where the intention is to allow a
 184  * client to filter in/out messages based on source, type, and ID.  Of course,
 185  * building a giant enum list of all debug output messages that Mesa might
 186  * generate is ridiculous, so instead we have our caller pass us a pointer to
 187  * static storage where the ID should get stored.  This ID will be shared
 188  * across all contexts for that message (which seems like a desirable
 189  * property, even if it's not expected by the spec), but note that it won't be
 190  * the same between executions if messages aren't generated in the same order.
 191  */
 192 void
 193 _mesa_debug_get_id(GLuint *id)
 194 {
 195    if (!(*id)) {
 196       simple_mtx_lock(&DynamicIDMutex);
 197       if (!(*id))
 198          *id = NextDynamicID++;
 199       simple_mtx_unlock(&DynamicIDMutex);
 200    }
 201 }
 202
 203 static void
 204 debug_message_clear(struct gl_debug_message *msg)
 205 {
 206    if (msg->message != (char*)out_of_memory)
 207       free(msg->message);
 208    msg->message = NULL;
 209    msg->length = 0;
 210 }
 211
 212 static void
 213 debug_message_store(struct gl_debug_message *msg,
 214                     enum mesa_debug_source source,
 215                     enum mesa_debug_type type, GLuint id,
 216                     enum mesa_debug_severity severity,
 217                     GLsizei len, const char *buf)
 218 {
 219    GLsizei length = len;
 220
 221    assert(!msg->message && !msg->length);
 222
 223    if (length < 0)
 224       length = strlen(buf);
 225
 226    msg->message = malloc(length+1);
 227    if (msg->message) {
 228       (void) strncpy(msg->message, buf, (size_t)length);
 229       msg->message[length] = '\0';
 230
 231       msg->length = len;
 232       msg->source = source;
 233       msg->type = type;
 234       msg->id = id;
 235       msg->severity = severity;
 236    } else {
 237       static GLuint oom_msg_id = 0;
 238       _mesa_debug_get_id(&oom_msg_id);
 239
 240       /* malloc failed! */
 241       msg->message = out_of_memory;
 242       msg->length = -1;
 243       msg->source = MESA_DEBUG_SOURCE_OTHER;
 244       msg->type = MESA_DEBUG_TYPE_ERROR;
 245       msg->id = oom_msg_id;
 246       msg->severity = MESA_DEBUG_SEVERITY_HIGH;
 247    }
 248 }
 249
 250 static void
 251 debug_namespace_init(struct gl_debug_namespace *ns)
 252 {
 253    make_empty_list(&ns->Elements);
 254
 255    /* Enable all the messages with severity HIGH or MEDIUM by default */
 256    ns->DefaultState = (1 << MESA_DEBUG_SEVERITY_MEDIUM ) |
 257                       (1 << MESA_DEBUG_SEVERITY_HIGH) |
 258                       (1 << MESA_DEBUG_SEVERITY_NOTIFICATION);
 259 }
 260
 261 static void
 262 debug_namespace_clear(struct gl_debug_namespace *ns)
 263 {
 264    struct simple_node *node, *tmp;
 265
 266    foreach_s(node, tmp, &ns->Elements)
 267       free(node);
 268 }
 269
 270 static bool
 271 debug_namespace_copy(struct gl_debug_namespace *dst,
 272                      const struct gl_debug_namespace *src)
 273 {
 274    struct simple_node *node;
 275
 276    dst->DefaultState = src->DefaultState;
 277
 278    make_empty_list(&dst->Elements);
 279    foreach(node, &src->Elements) {
 280       const struct gl_debug_element *elem =
 281          (const struct gl_debug_element *) node;
 282       struct gl_debug_element *copy;
 283
 284       copy = malloc(sizeof(*copy));
 285       if (!copy) {
 286          debug_namespace_clear(dst);
 287          return false;
 288       }
 289
 290       copy->ID = elem->ID;
 291       copy->State = elem->State;
 292       insert_at_tail(&dst->Elements, &copy->link);
 293    }
 294
 295    return true;
 296 }
 297
 298 /**
 299  * Set the state of \p id in the namespace.
 300  */
 301 static bool
 302 debug_namespace_set(struct gl_debug_namespace *ns,
 303                     GLuint id, bool enabled)
 304 {
 305    const uint32_t state = (enabled) ?
 306       ((1 << MESA_DEBUG_SEVERITY_COUNT) - 1) : 0;
 307    struct gl_debug_element *elem = NULL;
 308    struct simple_node *node;
 309
 310    /* find the element */
 311    foreach(node, &ns->Elements) {
 312       struct gl_debug_element *tmp = (struct gl_debug_element *) node;
 313       if (tmp->ID == id) {
 314          elem = tmp;
 315          break;
 316       }
 317    }
 318
 319    /* we do not need the element if it has the default state */
 320    if (ns->DefaultState == state) {
 321       if (elem) {
 322          remove_from_list(&elem->link);
 323          free(elem);
 324       }
 325       return true;
 326    }
 327
 328    if (!elem) {
 329       elem = malloc(sizeof(*elem));
 330       if (!elem)
 331          return false;
 332
 333       elem->ID = id;
 334       insert_at_tail(&ns->Elements, &elem->link);
 335    }
 336
 337    elem->State = state;
 338
 339    return true;
 340 }
 341
 342 /**
 343  * Set the default state of the namespace for \p severity.  When \p severity
 344  * is MESA_DEBUG_SEVERITY_COUNT, the default values for all severities are
 345  * updated.
 346  */
 347 static void
 348 debug_namespace_set_all(struct gl_debug_namespace *ns,
 349                         enum mesa_debug_severity severity,
 350                         bool enabled)
 351 {
 352    struct simple_node *node, *tmp;
 353    uint32_t mask, val;
 354
 355    /* set all elements to the same state */
 356    if (severity == MESA_DEBUG_SEVERITY_COUNT) {
 357       ns->DefaultState = (enabled) ? ((1 << severity) - 1) : 0;
 358       debug_namespace_clear(ns);
 359       make_empty_list(&ns->Elements);
 360       return;
 361    }
 362
 363    mask = 1 << severity;
 364    val = (enabled) ? mask : 0;
 365
 366    ns->DefaultState = (ns->DefaultState & ~mask) | val;
 367
 368    foreach_s(node, tmp, &ns->Elements) {
 369       struct gl_debug_element *elem = (struct gl_debug_element *) node;
 370
 371       elem->State = (elem->State & ~mask) | val;
 372       if (elem->State == ns->DefaultState) {
 373          remove_from_list(node);
 374          free(node);
 375       }
 376    }
 377 }
 378
 379 /**
 380  * Get the state of \p id in the namespace.
 381  */
 382 static bool
 383 debug_namespace_get(const struct gl_debug_namespace *ns, GLuint id,
 384                     enum mesa_debug_severity severity)
 385 {
 386    struct simple_node *node;
 387    uint32_t state;
 388
 389    state = ns->DefaultState;
 390    foreach(node, &ns->Elements) {
 391       struct gl_debug_element *elem = (struct gl_debug_element *) node;
 392
 393       if (elem->ID == id) {
 394          state = elem->State;
 395          break;
 396       }
 397    }
 398
 399    return (state & (1 << severity));
 400 }
 401
 402 /**
 403  * Allocate and initialize context debug state.
 404  */
 405 static struct gl_debug_state *
 406 debug_create(void)
 407 {
 408    struct gl_debug_state *debug;
 409    int s, t;
 410
 411    debug = CALLOC_STRUCT(gl_debug_state);
 412    if (!debug)
 413       return NULL;
 414
 415    debug->Groups[0] = malloc(sizeof(*debug->Groups[0]));
 416    if (!debug->Groups[0]) {
 417       free(debug);
 418       return NULL;
 419    }
 420
 421    /* Initialize state for filtering known debug messages. */
 422    for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
 423       for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
 424          debug_namespace_init(&debug->Groups[0]->Namespaces[s][t]);
 425    }
 426
 427    return debug;
 428 }
 429
 430 /**
 431  * Return true if the top debug group points to the group below it.
 432  */
 433 static bool
 434 debug_is_group_read_only(const struct gl_debug_state *debug)
 435 {
 436    const GLint gstack = debug->CurrentGroup;
 437    return (gstack > 0 && debug->Groups[gstack] == debug->Groups[gstack - 1]);
 438 }
 439
 440 /**
 441  * Make the top debug group writable.
 442  */
 443 static bool
 444 debug_make_group_writable(struct gl_debug_state *debug)
 445 {
 446    const GLint gstack = debug->CurrentGroup;
 447    const struct gl_debug_group *src = debug->Groups[gstack];
 448    struct gl_debug_group *dst;
 449    int s, t;
 450
 451    if (!debug_is_group_read_only(debug))
 452       return true;
 453
 454    dst = malloc(sizeof(*dst));
 455    if (!dst)
 456       return false;
 457
 458    for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
 459       for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
 460          if (!debug_namespace_copy(&dst->Namespaces[s][t],
 461                                    &src->Namespaces[s][t])) {
 462             /* error path! */
 463             for (t = t - 1; t >= 0; t--)
 464                debug_namespace_clear(&dst->Namespaces[s][t]);
 465             for (s = s - 1; s >= 0; s--) {
 466                for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
 467                   debug_namespace_clear(&dst->Namespaces[s][t]);
 468             }
 469             free(dst);
 470             return false;
 471          }
 472       }
 473    }
 474
 475    debug->Groups[gstack] = dst;
 476
 477    return true;
 478 }
 479
 480 /**
 481  * Free the top debug group.
 482  */
 483 static void
 484 debug_clear_group(struct gl_debug_state *debug)
 485 {
 486    const GLint gstack = debug->CurrentGroup;
 487
 488    if (!debug_is_group_read_only(debug)) {
 489       struct gl_debug_group *grp = debug->Groups[gstack];
 490       int s, t;
 491
 492       for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
 493          for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
 494             debug_namespace_clear(&grp->Namespaces[s][t]);
 495       }
 496
 497       free(grp);
 498    }
 499
 500    debug->Groups[gstack] = NULL;
 501 }
 502
 503 /**
 504  * Loop through debug group stack tearing down states for
 505  * filtering debug messages.  Then free debug output state.
 506  */
 507 static void
 508 debug_destroy(struct gl_debug_state *debug)
 509 {
 510    while (debug->CurrentGroup > 0) {
 511       debug_clear_group(debug);
 512       debug->CurrentGroup--;
 513    }
 514
 515    debug_clear_group(debug);
 516    free(debug);
 517 }
 518
 519 /**
 520  * Sets the state of the given message source/type/ID tuple.
 521  */
 522 static void
 523 debug_set_message_enable(struct gl_debug_state *debug,
 524                          enum mesa_debug_source source,
 525                          enum mesa_debug_type type,
 526                          GLuint id, GLboolean enabled)
 527 {
 528    const GLint gstack = debug->CurrentGroup;
 529    struct gl_debug_namespace *ns;
 530
 531    debug_make_group_writable(debug);
 532    ns = &debug->Groups[gstack]->Namespaces[source][type];
 533
 534    debug_namespace_set(ns, id, enabled);
 535 }
 536
 537 /*
 538  * Set the state of all message IDs found in the given intersection of
 539  * 'source', 'type', and 'severity'.  The _COUNT enum can be used for
 540  * GL_DONT_CARE (include all messages in the class).
 541  *
 542  * This requires both setting the state of all previously seen message
 543  * IDs in the hash table, and setting the default state for all
 544  * applicable combinations of source/type/severity, so that all the
 545  * yet-unknown message IDs that may be used in the future will be
 546  * impacted as if they were already known.
 547  */
 548 static void
 549 debug_set_message_enable_all(struct gl_debug_state *debug,
 550                              enum mesa_debug_source source,
 551                              enum mesa_debug_type type,
 552                              enum mesa_debug_severity severity,
 553                              GLboolean enabled)
 554 {
 555    const GLint gstack = debug->CurrentGroup;
 556    int s, t, smax, tmax;
 557
 558    if (source == MESA_DEBUG_SOURCE_COUNT) {
 559       source = 0;
 560       smax = MESA_DEBUG_SOURCE_COUNT;
 561    } else {
 562       smax = source+1;
 563    }
 564
 565    if (type == MESA_DEBUG_TYPE_COUNT) {
 566       type = 0;
 567       tmax = MESA_DEBUG_TYPE_COUNT;
 568    } else {
 569       tmax = type+1;
 570    }
 571
 572    debug_make_group_writable(debug);
 573
 574    for (s = source; s < smax; s++) {
 575       for (t = type; t < tmax; t++) {
 576          struct gl_debug_namespace *nspace =
 577             &debug->Groups[gstack]->Namespaces[s][t];
 578          debug_namespace_set_all(nspace, severity, enabled);
 579       }
 580    }
 581 }
 582
 583 /**
 584  * Returns if the given message source/type/ID tuple is enabled.
 585  */
 586 bool
 587 _mesa_debug_is_message_enabled(const struct gl_debug_state *debug,
 588                                enum mesa_debug_source source,
 589                                enum mesa_debug_type type,
 590                                GLuint id,
 591                                enum mesa_debug_severity severity)
 592 {
 593    const GLint gstack = debug->CurrentGroup;
 594    struct gl_debug_group *grp = debug->Groups[gstack];
 595    struct gl_debug_namespace *nspace = &grp->Namespaces[source][type];
 596
 597    if (!debug->DebugOutput)
 598       return false;
 599
 600    return debug_namespace_get(nspace, id, severity);
 601 }
 602
 603 /**
 604  * 'buf' is not necessarily a null-terminated string. When logging, copy
 605  * 'len' characters from it, store them in a new, null-terminated string,
 606  * and remember the number of bytes used by that string, *including*
 607  * the null terminator this time.
 608  */
 609 static void
 610 debug_log_message(struct gl_debug_state *debug,
 611                   enum mesa_debug_source source,
 612                   enum mesa_debug_type type, GLuint id,
 613                   enum mesa_debug_severity severity,
 614                   GLsizei len, const char *buf)
 615 {
 616    struct gl_debug_log *log = &debug->Log;
 617    GLint nextEmpty;
 618    struct gl_debug_message *emptySlot;
 619
 620    if (debug->LogToStderr) {
 621       _mesa_log("Mesa debug output: %.*s\n", len, buf);
 622    }
 623
 624    assert(len < MAX_DEBUG_MESSAGE_LENGTH);
 625
 626    if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
 627       return;
 628
 629    nextEmpty = (log->NextMessage + log->NumMessages)
 630       % MAX_DEBUG_LOGGED_MESSAGES;
 631    emptySlot = &log->Messages[nextEmpty];
 632
 633    debug_message_store(emptySlot, source, type,
 634                        id, severity, len, buf);
 635
 636    log->NumMessages++;
 637 }
 638
 639 /**
 640  * Return the oldest debug message out of the log.
 641  */
 642 static const struct gl_debug_message *
 643 debug_fetch_message(const struct gl_debug_state *debug)
 644 {
 645    const struct gl_debug_log *log = &debug->Log;
 646
 647    return (log->NumMessages) ? &log->Messages[log->NextMessage] : NULL;
 648 }
 649
 650 /**
 651  * Delete the oldest debug messages out of the log.
 652  */
 653 static void
 654 debug_delete_messages(struct gl_debug_state *debug, int count)
 655 {
 656    struct gl_debug_log *log = &debug->Log;
 657
 658    if (count > log->NumMessages)
 659       count = log->NumMessages;
 660
 661    while (count--) {
 662       struct gl_debug_message *msg = &log->Messages[log->NextMessage];
 663
 664       debug_message_clear(msg);
 665
 666       log->NumMessages--;
 667       log->NextMessage++;
 668       log->NextMessage %= MAX_DEBUG_LOGGED_MESSAGES;
 669    }
 670 }
 671
 672 static struct gl_debug_message *
 673 debug_get_group_message(struct gl_debug_state *debug)
 674 {
 675    return &debug->GroupMessages[debug->CurrentGroup];
 676 }
 677
 678 static void
 679 debug_push_group(struct gl_debug_state *debug)
 680 {
 681    const GLint gstack = debug->CurrentGroup;
 682
 683    /* just point to the previous stack */
 684    debug->Groups[gstack + 1] = debug->Groups[gstack];
 685    debug->CurrentGroup++;
 686 }
 687
 688 static void
 689 debug_pop_group(struct gl_debug_state *debug)
 690 {
 691    debug_clear_group(debug);
 692    debug->CurrentGroup--;
 693 }
 694
 695
 696 /**
 697  * Lock and return debug state for the context.  The debug state will be
 698  * allocated and initialized upon the first call.  When NULL is returned, the
 699  * debug state is not locked.
 700  */
 701 static struct gl_debug_state *
 702 _mesa_lock_debug_state(struct gl_context *ctx)
 703 {
 704    simple_mtx_lock(&ctx->DebugMutex);
 705
 706    if (!ctx->Debug) {
 707       ctx->Debug = debug_create();
 708       if (!ctx->Debug) {
 709          GET_CURRENT_CONTEXT(cur);
 710          simple_mtx_unlock(&ctx->DebugMutex);
 711
 712          /*
 713           * This function may be called from other threads.  When that is the
 714           * case, we cannot record this OOM error.
 715           */
 716          if (ctx == cur)
 717             _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
 718
 719          return NULL;
 720       }
 721    }
 722
 723    return ctx->Debug;
 724 }
 725
 726 static void
 727 _mesa_unlock_debug_state(struct gl_context *ctx)
 728 {
 729    simple_mtx_unlock(&ctx->DebugMutex);
 730 }
 731
 732 /**
 733  * Set the integer debug state specified by \p pname.  This can be called from
 734  * _mesa_set_enable for example.
 735  */
 736 bool
 737 _mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val)
 738 {
 739    struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
 740
 741    if (!debug)
 742       return false;
 743
 744    switch (pname) {
 745    case GL_DEBUG_OUTPUT:
 746       debug->DebugOutput = (val != 0);
 747       break;
 748    case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
 749       debug->SyncOutput = (val != 0);
 750       break;
 751    default:
 752       assert(!"unknown debug output param");
 753       break;
 754    }
 755
 756    _mesa_unlock_debug_state(ctx);
 757
 758    return true;
 759 }
 760
 761 /**
 762  * Query the integer debug state specified by \p pname.  This can be called
 763  * _mesa_GetIntegerv for example.
 764  */
 765 GLint
 766 _mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname)
 767 {
 768    GLint val;
 769
 770    struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
 771    if (!debug)
 772       return 0;
 773
 774    switch (pname) {
 775    case GL_DEBUG_OUTPUT:
 776       val = debug->DebugOutput;
 777       break;
 778    case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
 779       val = debug->SyncOutput;
 780       break;
 781    case GL_DEBUG_LOGGED_MESSAGES:
 782       val = debug->Log.NumMessages;
 783       break;
 784    case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
 785       val = (debug->Log.NumMessages) ?
 786          debug->Log.Messages[debug->Log.NextMessage].length + 1 : 0;
 787       break;
 788    case GL_DEBUG_GROUP_STACK_DEPTH:
 789       val = debug->CurrentGroup + 1;
 790       break;
 791    default:
 792       assert(!"unknown debug output param");
 793       val = 0;
 794       break;
 795    }
 796
 797    _mesa_unlock_debug_state(ctx);
 798
 799    return val;
 800 }
 801
 802 /**
 803  * Query the pointer debug state specified by \p pname.  This can be called
 804  * _mesa_GetPointerv for example.
 805  */
 806 void *
 807 _mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname)
 808 {
 809    void *val;
 810    struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
 811
 812    if (!debug)
 813       return NULL;
 814
 815    switch (pname) {
 816    case GL_DEBUG_CALLBACK_FUNCTION_ARB:
 817       val = (void *) debug->Callback;
 818       break;
 819    case GL_DEBUG_CALLBACK_USER_PARAM_ARB:
 820       val = (void *) debug->CallbackData;
 821       break;
 822    default:
 823       assert(!"unknown debug output param");
 824       val = NULL;
 825       break;
 826    }
 827
 828    _mesa_unlock_debug_state(ctx);
 829
 830    return val;
 831 }
 832
 833 /**
 834  * Insert a debug message.  The mutex is assumed to be locked, and will be
 835  * unlocked by this call.
 836  */
 837 static void
 838 log_msg_locked_and_unlock(struct gl_context *ctx,
 839                           enum mesa_debug_source source,
 840                           enum mesa_debug_type type, GLuint id,
 841                           enum mesa_debug_severity severity,
 842                           GLint len, const char *buf)
 843 {
 844    struct gl_debug_state *debug = ctx->Debug;
 845
 846    if (!_mesa_debug_is_message_enabled(debug, source, type, id, severity)) {
 847       _mesa_unlock_debug_state(ctx);
 848       return;
 849    }
 850
 851    if (ctx->Debug->Callback) {
 852       /* Call the user's callback function */
 853       GLenum gl_source = debug_source_enums[source];
 854       GLenum gl_type = debug_type_enums[type];
 855       GLenum gl_severity = debug_severity_enums[severity];
 856       GLDEBUGPROC callback = ctx->Debug->Callback;
 857       const void *data = ctx->Debug->CallbackData;
 858
 859       /*
 860        * When ctx->Debug->SyncOutput is GL_FALSE, the client is prepared for
 861        * unsynchronous calls.  When it is GL_TRUE, we will not spawn threads.
 862        * In either case, we can call the callback unlocked.
 863        */
 864       _mesa_unlock_debug_state(ctx);
 865       callback(gl_source, gl_type, id, gl_severity, len, buf, data);
 866    }
 867    else {
 868       /* add debug message to queue */
 869       debug_log_message(ctx->Debug, source, type, id, severity, len, buf);
 870       _mesa_unlock_debug_state(ctx);
 871    }
 872 }
 873
 874 /**
 875  * Log a client or driver debug message.
 876  */
 877 void
 878 _mesa_log_msg(struct gl_context *ctx, enum mesa_debug_source source,
 879               enum mesa_debug_type type, GLuint id,
 880               enum mesa_debug_severity severity, GLint len, const char *buf)
 881 {
 882    struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
 883
 884    if (!debug)
 885       return;
 886
 887    log_msg_locked_and_unlock(ctx, source, type, id, severity, len, buf);
 888 }
 889
 890
 891 /**
 892  * Verify that source, type, and severity are valid enums.
 893  *
 894  * The 'caller' param is used for handling values available
 895  * only in glDebugMessageInsert or glDebugMessageControl
 896  */
 897 static GLboolean
 898 validate_params(struct gl_context *ctx, unsigned caller,
 899                 const char *callerstr, GLenum source, GLenum type,
 900                 GLenum severity)
 901 {
 902 #define INSERT 1
 903 #define CONTROL 2
 904    switch(source) {
 905    case GL_DEBUG_SOURCE_APPLICATION_ARB:
 906    case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
 907       break;
 908    case GL_DEBUG_SOURCE_API_ARB:
 909    case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
 910    case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
 911    case GL_DEBUG_SOURCE_OTHER_ARB:
 912       if (caller != INSERT)
 913          break;
 914       else
 915          goto error;
 916    case GL_DONT_CARE:
 917       if (caller == CONTROL)
 918          break;
 919       else
 920          goto error;
 921    default:
 922       goto error;
 923    }
 924
 925    switch(type) {
 926    case GL_DEBUG_TYPE_ERROR_ARB:
 927    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
 928    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
 929    case GL_DEBUG_TYPE_PERFORMANCE_ARB:
 930    case GL_DEBUG_TYPE_PORTABILITY_ARB:
 931    case GL_DEBUG_TYPE_OTHER_ARB:
 932    case GL_DEBUG_TYPE_MARKER:
 933    case GL_DEBUG_TYPE_PUSH_GROUP:
 934    case GL_DEBUG_TYPE_POP_GROUP:
 935       break;
 936    case GL_DONT_CARE:
 937       if (caller == CONTROL)
 938          break;
 939       else
 940          goto error;
 941    default:
 942       goto error;
 943    }
 944
 945    switch(severity) {
 946    case GL_DEBUG_SEVERITY_HIGH_ARB:
 947    case GL_DEBUG_SEVERITY_MEDIUM_ARB:
 948    case GL_DEBUG_SEVERITY_LOW_ARB:
 949    case GL_DEBUG_SEVERITY_NOTIFICATION:
 950       break;
 951    case GL_DONT_CARE:
 952       if (caller == CONTROL)
 953          break;
 954       else
 955          goto error;
 956    default:
 957       goto error;
 958    }
 959    return GL_TRUE;
 960
 961 error:
 962    _mesa_error(ctx, GL_INVALID_ENUM, "bad values passed to %s"
 963                "(source=0x%x, type=0x%x, severity=0x%x)", callerstr,
 964                source, type, severity);
 965
 966    return GL_FALSE;
 967 }
 968
 969
 970 static GLboolean
 971 validate_length(struct gl_context *ctx, const char *callerstr, GLsizei length,
 972                 const GLchar *buf)
 973 {
 974
 975    if (length < 0) {
 976       GLsizei len = strlen(buf);
 977
 978       if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
 979          _mesa_error(ctx, GL_INVALID_VALUE,
 980                     "%s(null terminated string length=%d, is not less than "
 981                     "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, len,
 982                     MAX_DEBUG_MESSAGE_LENGTH);
 983          return GL_FALSE;
 984       }
 985    }
 986
 987    if (length >= MAX_DEBUG_MESSAGE_LENGTH) {
 988       _mesa_error(ctx, GL_INVALID_VALUE,
 989                  "%s(length=%d, which is not less than "
 990                  "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, length,
 991                  MAX_DEBUG_MESSAGE_LENGTH);
 992       return GL_FALSE;
 993    }
 994
 995    return GL_TRUE;
 996 }
 997
 998
 999 void GLAPIENTRY
1000 _mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
1001                          GLenum severity, GLint length,
1002                          const GLchar *buf)
1003 {
1004    GET_CURRENT_CONTEXT(ctx);
1005    const char *callerstr;
1006
1007    if (_mesa_is_desktop_gl(ctx))
1008       callerstr = "glDebugMessageInsert";
1009    else
1010       callerstr = "glDebugMessageInsertKHR";
1011
1012    if (!validate_params(ctx, INSERT, callerstr, source, type, severity))
1013       return; /* GL_INVALID_ENUM */
1014
1015    if (!validate_length(ctx, callerstr, length, buf))
1016       return; /* GL_INVALID_VALUE */
1017
1018    /* if length not specified, string will be null terminated: */
1019    if (length < 0)
1020       length = strlen(buf);
1021
1022    _mesa_log_msg(ctx, gl_enum_to_debug_source(source),
1023                  gl_enum_to_debug_type(type), id,
1024                  gl_enum_to_debug_severity(severity),
1025                  length, buf);
1026
1027    if (type == GL_DEBUG_TYPE_MARKER && ctx->Driver.EmitStringMarker) {
1028       ctx->Driver.EmitStringMarker(ctx, buf, length);
1029    }
1030 }
1031
1032
1033 GLuint GLAPIENTRY
1034 _mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum *sources,
1035                          GLenum *types, GLenum *ids, GLenum *severities,
1036                          GLsizei *lengths, GLchar *messageLog)
1037 {
1038    GET_CURRENT_CONTEXT(ctx);
1039    struct gl_debug_state *debug;
1040    const char *callerstr;
1041    GLuint ret;
1042
1043    if (_mesa_is_desktop_gl(ctx))
1044       callerstr = "glGetDebugMessageLog";
1045    else
1046       callerstr = "glGetDebugMessageLogKHR";
1047
1048    if (!messageLog)
1049       logSize = 0;
1050
1051    if (logSize < 0) {
1052       _mesa_error(ctx, GL_INVALID_VALUE,
1053                   "%s(logSize=%d : logSize must not be negative)",
1054                   callerstr, logSize);
1055       return 0;
1056    }
1057
1058    debug = _mesa_lock_debug_state(ctx);
1059    if (!debug)
1060       return 0;
1061
1062    for (ret = 0; ret < count; ret++) {
1063       const struct gl_debug_message *msg = debug_fetch_message(debug);
1064       GLsizei len;
1065
1066       if (!msg)
1067          break;
1068
1069       len = msg->length;
1070       if (len < 0)
1071          len = strlen(msg->message);
1072
1073       if (logSize < len+1 && messageLog != NULL)
1074          break;
1075
1076       if (messageLog) {
1077          assert(msg->message[len] == '\0');
1078          (void) strncpy(messageLog, msg->message, (size_t)len+1);
1079
1080          messageLog += len+1;
1081          logSize -= len+1;
1082       }
1083
1084       if (lengths)
1085          *lengths++ = len+1;
1086       if (severities)
1087          *severities++ = debug_severity_enums[msg->severity];
1088       if (sources)
1089          *sources++ = debug_source_enums[msg->source];
1090       if (types)
1091          *types++ = debug_type_enums[msg->type];
1092       if (ids)
1093          *ids++ = msg->id;
1094
1095       debug_delete_messages(debug, 1);
1096    }
1097
1098    _mesa_unlock_debug_state(ctx);
1099
1100    return ret;
1101 }
1102
1103
1104 void GLAPIENTRY
1105 _mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type,
1106                           GLenum gl_severity, GLsizei count,
1107                           const GLuint *ids, GLboolean enabled)
1108 {
1109    GET_CURRENT_CONTEXT(ctx);
1110    enum mesa_debug_source source = gl_enum_to_debug_source(gl_source);
1111    enum mesa_debug_type type = gl_enum_to_debug_type(gl_type);
1112    enum mesa_debug_severity severity = gl_enum_to_debug_severity(gl_severity);
1113    const char *callerstr;
1114    struct gl_debug_state *debug;
1115
1116    if (_mesa_is_desktop_gl(ctx))
1117       callerstr = "glDebugMessageControl";
1118    else
1119       callerstr = "glDebugMessageControlKHR";
1120
1121    if (count < 0) {
1122       _mesa_error(ctx, GL_INVALID_VALUE,
1123                   "%s(count=%d : count must not be negative)", callerstr,
1124                   count);
1125       return;
1126    }
1127
1128    if (!validate_params(ctx, CONTROL, callerstr, gl_source, gl_type,
1129                         gl_severity))
1130       return; /* GL_INVALID_ENUM */
1131
1132    if (count && (gl_severity != GL_DONT_CARE || gl_type == GL_DONT_CARE
1133                  || gl_source == GL_DONT_CARE)) {
1134       _mesa_error(ctx, GL_INVALID_OPERATION,
1135                   "%s(When passing an array of ids, severity must be"
1136          " GL_DONT_CARE, and source and type must not be GL_DONT_CARE.",
1137                   callerstr);
1138       return;
1139    }
1140
1141    debug = _mesa_lock_debug_state(ctx);
1142    if (!debug)
1143       return;
1144
1145    if (count) {
1146       GLsizei i;
1147       for (i = 0; i < count; i++)
1148          debug_set_message_enable(debug, source, type, ids[i], enabled);
1149    }
1150    else {
1151       debug_set_message_enable_all(debug, source, type, severity, enabled);
1152    }
1153
1154    _mesa_unlock_debug_state(ctx);
1155 }
1156
1157
1158 void GLAPIENTRY
1159 _mesa_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
1160 {
1161    GET_CURRENT_CONTEXT(ctx);
1162    struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
1163    if (debug) {
1164       debug->Callback = callback;
1165       debug->CallbackData = userParam;
1166       _mesa_unlock_debug_state(ctx);
1167    }
1168 }
1169
1170
1171 void GLAPIENTRY
1172 _mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
1173                      const GLchar *message)
1174 {
1175    GET_CURRENT_CONTEXT(ctx);
1176    const char *callerstr;
1177    struct gl_debug_state *debug;
1178    struct gl_debug_message *emptySlot;
1179
1180    if (_mesa_is_desktop_gl(ctx))
1181       callerstr = "glPushDebugGroup";
1182    else
1183       callerstr = "glPushDebugGroupKHR";
1184
1185    switch(source) {
1186    case GL_DEBUG_SOURCE_APPLICATION:
1187    case GL_DEBUG_SOURCE_THIRD_PARTY:
1188       break;
1189    default:
1190       _mesa_error(ctx, GL_INVALID_ENUM, "bad value passed to %s"
1191                   "(source=0x%x)", callerstr, source);
1192       return;
1193    }
1194
1195    if (!validate_length(ctx, callerstr, length, message))
1196       return; /* GL_INVALID_VALUE */
1197
1198    if (length < 0)
1199       length = strlen(message);
1200
1201    debug = _mesa_lock_debug_state(ctx);
1202    if (!debug)
1203       return;
1204
1205    if (debug->CurrentGroup >= MAX_DEBUG_GROUP_STACK_DEPTH-1) {
1206       _mesa_unlock_debug_state(ctx);
1207       _mesa_error(ctx, GL_STACK_OVERFLOW, "%s", callerstr);
1208       return;
1209    }
1210
1211    /* pop reuses the message details from push so we store this */
1212    emptySlot = debug_get_group_message(debug);
1213    debug_message_store(emptySlot,
1214                        gl_enum_to_debug_source(source),
1215                        gl_enum_to_debug_type(GL_DEBUG_TYPE_PUSH_GROUP),
1216                        id,
1217                        gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
1218                        length, message);
1219
1220    debug_push_group(debug);
1221
1222    log_msg_locked_and_unlock(ctx,
1223          gl_enum_to_debug_source(source),
1224          MESA_DEBUG_TYPE_PUSH_GROUP, id,
1225          MESA_DEBUG_SEVERITY_NOTIFICATION, length,
1226          message);
1227 }
1228
1229
1230 void GLAPIENTRY
1231 _mesa_PopDebugGroup(void)
1232 {
1233    GET_CURRENT_CONTEXT(ctx);
1234    const char *callerstr;
1235    struct gl_debug_state *debug;
1236    struct gl_debug_message *gdmessage, msg;
1237
1238    if (_mesa_is_desktop_gl(ctx))
1239       callerstr = "glPopDebugGroup";
1240    else
1241       callerstr = "glPopDebugGroupKHR";
1242
1243    debug = _mesa_lock_debug_state(ctx);
1244    if (!debug)
1245       return;
1246
1247    if (debug->CurrentGroup <= 0) {
1248       _mesa_unlock_debug_state(ctx);
1249       _mesa_error(ctx, GL_STACK_UNDERFLOW, "%s", callerstr);
1250       return;
1251    }
1252
1253    debug_pop_group(debug);
1254
1255    /* make a shallow copy */
1256    gdmessage = debug_get_group_message(debug);
1257    msg = *gdmessage;
1258    gdmessage->message = NULL;
1259    gdmessage->length = 0;
1260
1261    log_msg_locked_and_unlock(ctx,
1262          msg.source,
1263          gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP),
1264          msg.id,
1265          gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
1266          msg.length, msg.message);
1267
1268    debug_message_clear(&msg);
1269 }
1270
1271
1272 void
1273 _mesa_init_debug_output(struct gl_context *ctx)
1274 {
1275    simple_mtx_init(&ctx->DebugMutex, mtx_plain);
1276
1277    if (MESA_DEBUG_FLAGS & DEBUG_CONTEXT) {
1278       /* If the MESA_DEBUG env is set to "context", we'll turn on the
1279        * GL_CONTEXT_FLAG_DEBUG_BIT context flag and log debug output
1280        * messages to stderr (or whatever MESA_LOG_FILE points at).
1281        */
1282       struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
1283       if (!debug) {
1284          return;
1285       }
1286       debug->DebugOutput = GL_TRUE;
1287       debug->LogToStderr = GL_TRUE;
1288       ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_DEBUG_BIT;
1289       _mesa_unlock_debug_state(ctx);
1290    }
1291 }
1292
1293
1294 void
1295 _mesa_free_errors_data(struct gl_context *ctx)
1296 {
1297    if (ctx->Debug) {
1298       debug_destroy(ctx->Debug);
1299       /* set to NULL just in case it is used before context is completely gone. */
1300       ctx->Debug = NULL;
1301    }
1302
1303    simple_mtx_destroy(&ctx->DebugMutex);
1304 }
1305
1306 void GLAPIENTRY
1307 _mesa_StringMarkerGREMEDY(GLsizei len, const GLvoid *string)
1308 {
1309    GET_CURRENT_CONTEXT(ctx);
1310    if (ctx->Extensions.GREMEDY_string_marker) {
1311       /* if length not specified, string will be null terminated: */
1312       if (len <= 0)
1313          len = strlen(string);
1314       ctx->Driver.EmitStringMarker(ctx, string, len);
1315    } else {
1316       _mesa_error(ctx, GL_INVALID_OPERATION, "StringMarkerGREMEDY");
1317    }
1318 }