src/glx/glxcurrent.c

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 /**
  32  * \file glxcurrent.c
  33  * Client-side GLX interface for current context management.
  34  */
  35
  36 #include <pthread.h>
  37
  38 #include "glxclient.h"
  39 #include "glapi.h"
  40 #include "glx_error.h"
  41
  42 /*
  43 ** We setup some dummy structures here so that the API can be used
  44 ** even if no context is current.
  45 */
  46
  47 static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
  48 static struct glx_context_vtable dummyVtable;
  49 /*
  50 ** Dummy context used by small commands when there is no current context.
  51 ** All the
  52 ** gl and glx entry points are designed to operate as nop's when using
  53 ** the dummy context structure.
  54 */
  55 struct glx_context dummyContext = {
  56    &dummyBuffer[0],
  57    &dummyBuffer[0],
  58    &dummyBuffer[0],
  59    &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
  60    sizeof(dummyBuffer),
  61    &dummyVtable
  62 };
  63
  64 /*
  65  * Current context management and locking
  66  */
  67
  68 _X_HIDDEN pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
  69
  70 # if defined( GLX_USE_TLS )
  71
  72 /**
  73  * Per-thread GLX context pointer.
  74  *
  75  * \c __glXSetCurrentContext is written is such a way that this pointer can
  76  * \b never be \c NULL.  This is important!  Because of this
  77  * \c __glXGetCurrentContext can be implemented as trivial macro.
  78  */
  79 __thread void *__glX_tls_Context __attribute__ ((tls_model("initial-exec")))
  80    = &dummyContext;
  81
  82 _X_HIDDEN void
  83 __glXSetCurrentContext(struct glx_context * c)
  84 {
  85    __glX_tls_Context = (c != NULL) ? c : &dummyContext;
  86 }
  87
  88 # else
  89
  90 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
  91
  92 /**
  93  * Per-thread data key.
  94  *
  95  * Once \c init_thread_data has been called, the per-thread data key will
  96  * take a value of \c NULL.  As each new thread is created the default
  97  * value, in that thread, will be \c NULL.
  98  */
  99 static pthread_key_t ContextTSD;
 100
 101 /**
 102  * Initialize the per-thread data key.
 103  *
 104  * This function is called \b exactly once per-process (not per-thread!) to
 105  * initialize the per-thread data key.  This is ideally done using the
 106  * \c pthread_once mechanism.
 107  */
 108 static void
 109 init_thread_data(void)
 110 {
 111    if (pthread_key_create(&ContextTSD, NULL) != 0) {
 112       perror("pthread_key_create");
 113       exit(-1);
 114    }
 115 }
 116
 117 _X_HIDDEN void
 118 __glXSetCurrentContext(struct glx_context * c)
 119 {
 120    pthread_once(&once_control, init_thread_data);
 121    pthread_setspecific(ContextTSD, c);
 122 }
 123
 124 _X_HIDDEN struct glx_context *
 125 __glXGetCurrentContext(void)
 126 {
 127    void *v;
 128
 129    pthread_once(&once_control, init_thread_data);
 130
 131    v = pthread_getspecific(ContextTSD);
 132    return (v == NULL) ? &dummyContext : (struct glx_context *) v;
 133 }
 134
 135 # endif /* defined( GLX_USE_TLS ) */
 136
 137
 138 _X_HIDDEN void
 139 __glXSetCurrentContextNull(void)
 140 {
 141    __glXSetCurrentContext(&dummyContext);
 142 #if defined(GLX_DIRECT_RENDERING)
 143    _glapi_set_dispatch(NULL);   /* no-op functions */
 144    _glapi_set_context(NULL);
 145 #endif
 146 }
 147
 148 _GLX_PUBLIC GLXContext
 149 glXGetCurrentContext(void)
 150 {
 151    struct glx_context *cx = __glXGetCurrentContext();
 152
 153    if (cx == &dummyContext) {
 154       return NULL;
 155    }
 156    else {
 157       return (GLXContext) cx;
 158    }
 159 }
 160
 161 _GLX_PUBLIC GLXDrawable
 162 glXGetCurrentDrawable(void)
 163 {
 164    struct glx_context *gc = __glXGetCurrentContext();
 165    return gc->currentDrawable;
 166 }
 167
 168 /**
 169  * Make a particular context current.
 170  *
 171  * \note This is in this file so that it can access dummyContext.
 172  */
 173 static Bool
 174 MakeContextCurrent(Display * dpy, GLXDrawable draw,
 175                    GLXDrawable read, GLXContext gc_user)
 176 {
 177    struct glx_context *gc = (struct glx_context *) gc_user;
 178    struct glx_context *oldGC = __glXGetCurrentContext();
 179
 180    /* Make sure that the new context has a nonzero ID.  In the request,
 181     * a zero context ID is used only to mean that we bind to no current
 182     * context.
 183     */
 184    if ((gc != NULL) && (gc->xid == None)) {
 185       return GL_FALSE;
 186    }
 187
 188    _glapi_check_multithread();
 189
 190    __glXLock();
 191    if (oldGC == gc &&
 192        gc->currentDrawable == draw && gc->currentReadable == read) {
 193       __glXUnlock();
 194       return True;
 195    }
 196
 197    /* can't have only one be 0 */
 198    if (!!draw != !!read) {
 199       __glXUnlock();
 200       __glXSendError(dpy, BadMatch, None, X_GLXMakeContextCurrent, True);
 201       return False;
 202    }
 203
 204    if (oldGC != &dummyContext) {
 205       if (--oldGC->thread_refcount == 0) {
 206          oldGC->vtable->unbind(oldGC, gc);
 207          oldGC->currentDpy = 0;
 208       }
 209    }
 210
 211    if (gc) {
 212       /* Attempt to bind the context.  We do this before mucking with
 213        * gc and __glXSetCurrentContext to properly handle our state in
 214        * case of an error.
 215        *
 216        * If an error occurs, set the Null context since we've already
 217        * blown away our old context.  The caller is responsible for
 218        * figuring out how to handle setting a valid context.
 219        */
 220       if (gc->vtable->bind(gc, oldGC, draw, read) != Success) {
 221          __glXSetCurrentContextNull();
 222          __glXUnlock();
 223          __glXSendError(dpy, GLXBadContext, None, X_GLXMakeContextCurrent,
 224                         False);
 225          return GL_FALSE;
 226       }
 227
 228       if (gc->thread_refcount == 0) {
 229          gc->currentDpy = dpy;
 230          gc->currentDrawable = draw;
 231          gc->currentReadable = read;
 232       }
 233       gc->thread_refcount++;
 234       __glXSetCurrentContext(gc);
 235    } else {
 236       __glXSetCurrentContextNull();
 237    }
 238
 239    if (oldGC->thread_refcount == 0 && oldGC != &dummyContext && oldGC->xid == None) {
 240       /* We are switching away from a context that was
 241        * previously destroyed, so we need to free the memory
 242        * for the old handle. */
 243       oldGC->vtable->destroy(oldGC);
 244    }
 245
 246    __glXUnlock();
 247
 248    /* The indirect vertex array state must to be initialised after we
 249     * have setup the context, as it needs to query server attributes.
 250     */
 251    if (gc && !gc->isDirect) {
 252       __GLXattribute *state = gc->client_state_private;
 253       if (state && state->array_state == NULL) {
 254          glGetString(GL_EXTENSIONS);
 255          glGetString(GL_VERSION);
 256          __glXInitVertexArrayState(gc);
 257       }
 258    }
 259
 260    return GL_TRUE;
 261 }
 262
 263
 264 _GLX_PUBLIC Bool
 265 glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
 266 {
 267    return MakeContextCurrent(dpy, draw, draw, gc);
 268 }
 269
 270 _GLX_PUBLIC
 271 GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
 272           (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
 273           (dpy, d, r, ctx), MakeContextCurrent)
 274
 275 _GLX_PUBLIC
 276 GLX_ALIAS(Bool, glXMakeContextCurrent,
 277           (Display * dpy, GLXDrawable d, GLXDrawable r,
 278            GLXContext ctx), (dpy, d, r, ctx), MakeContextCurrent)