1/* 2 * Mesa 3-D graphics library 3 * Version: 7.1 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * 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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26/* 27 * This file manages the OpenGL API dispatch layer. 28 * The dispatch table (struct _glapi_table) is basically just a list 29 * of function pointers. 30 * There are functions to set/get the current dispatch table for the 31 * current thread and to manage registration/dispatch of dynamically 32 * added extension functions. 33 * 34 * It's intended that this file and the other glapi*.[ch] files are 35 * flexible enough to be reused in several places: XFree86, DRI- 36 * based libGL.so, and perhaps the SGI SI. 37 * 38 * NOTE: There are no dependencies on Mesa in this code. 39 * 40 * Versions (API changes): 41 * 2000/02/23 - original version for Mesa 3.3 and XFree86 4.0 42 * 2001/01/16 - added dispatch override feature for Mesa 3.5 43 * 2002/06/28 - added _glapi_set_warning_func(), Mesa 4.1. 44 * 2002/10/01 - _glapi_get_proc_address() will now generate new entrypoints 45 * itself (using offset ~0). _glapi_add_entrypoint() can be 46 * called afterward and it'll fill in the correct dispatch 47 * offset. This allows DRI libGL to avoid probing for DRI 48 * drivers! No changes to the public glapi interface. 49 */ 50 51#include "u_current.h" 52#include "u_thread.h" 53 54#ifndef MAPI_MODE_UTIL 55 56#include "table.h" 57#include "stub.h" 58 59#else 60 61extern void init_glapi_relocs_once(void); 62extern void (*__glapi_noop_table[])(void); 63 64#define table_noop_array __glapi_noop_table 65#define stub_init_once() init_glapi_relocs_once() 66 67#endif 68 69/** 70 * \name Current dispatch and current context control variables 71 * 72 * Depending on whether or not multithreading is support, and the type of 73 * support available, several variables are used to store the current context 74 * pointer and the current dispatch table pointer. In the non-threaded case, 75 * the variables \c _glapi_Dispatch and \c _glapi_Context are used for this 76 * purpose. 77 * 78 * In the "normal" threaded case, the variables \c _glapi_Dispatch and 79 * \c _glapi_Context will be \c NULL if an application is detected as being 80 * multithreaded. Single-threaded applications will use \c _glapi_Dispatch 81 * and \c _glapi_Context just like the case without any threading support. 82 * When \c _glapi_Dispatch and \c _glapi_Context are \c NULL, the thread state 83 * data \c _gl_DispatchTSD and \c ContextTSD are used. Drivers and the 84 * static dispatch functions access these variables via \c _glapi_get_dispatch 85 * and \c _glapi_get_context. 86 * 87 * There is a race condition in setting \c _glapi_Dispatch to \c NULL. It is 88 * possible for the original thread to be setting it at the same instant a new 89 * thread, perhaps running on a different processor, is clearing it. Because 90 * of that, \c ThreadSafe, which can only ever be changed to \c GL_TRUE, is 91 * used to determine whether or not the application is multithreaded. 92 * 93 * In the TLS case, the variables \c _glapi_Dispatch and \c _glapi_Context are 94 * hardcoded to \c NULL. Instead the TLS variables \c _glapi_tls_Dispatch and 95 * \c _glapi_tls_Context are used. Having \c _glapi_Dispatch and 96 * \c _glapi_Context be hardcoded to \c NULL maintains binary compatability 97 * between TLS enabled loaders and non-TLS DRI drivers. 98 */ 99/*@{*/ 100#if defined(GLX_USE_TLS) 101 102__thread struct mapi_table *u_current_table 103 __attribute__((tls_model("initial-exec"))) 104 = (struct mapi_table *) table_noop_array; 105 106__thread void *u_current_user 107 __attribute__((tls_model("initial-exec"))); 108 109#else 110 111struct mapi_table *u_current_table = 112 (struct mapi_table *) table_noop_array; 113void *u_current_user; 114 115#ifdef THREADS 116struct u_tsd u_current_table_tsd; 117static struct u_tsd u_current_user_tsd; 118static int ThreadSafe; 119#endif /* THREADS */ 120 121#endif /* defined(GLX_USE_TLS) */ 122/*@}*/ 123 124 125void 126u_current_destroy(void) 127{ 128#if defined(THREADS) && defined(WIN32) 129 u_tsd_destroy(&u_current_table_tsd); 130 u_tsd_destroy(&u_current_user_tsd); 131#endif 132} 133 134 135#if defined(THREADS) && !defined(GLX_USE_TLS) 136 137static void 138u_current_init_tsd(void) 139{ 140 u_tsd_init(&u_current_table_tsd); 141 u_tsd_init(&u_current_user_tsd); 142} 143 144/** 145 * Mutex for multithread check. 146 */ 147u_mutex_declare_static(ThreadCheckMutex); 148 149/** 150 * We should call this periodically from a function such as glXMakeCurrent 151 * in order to test if multiple threads are being used. 152 */ 153void 154u_current_init(void) 155{ 156 static unsigned long knownID; 157 static int firstCall = 1; 158 159 if (ThreadSafe) 160 return; 161 162 u_mutex_lock(ThreadCheckMutex); 163 if (firstCall) { 164 u_current_init_tsd(); 165 166 knownID = u_thread_self(); 167 firstCall = 0; 168 } 169 else if (knownID != u_thread_self()) { 170 ThreadSafe = 1; 171 u_current_set(NULL); 172 u_current_set_user(NULL); 173 } 174 u_mutex_unlock(ThreadCheckMutex); 175} 176 177#else 178 179void 180u_current_init(void) 181{ 182} 183 184#endif 185 186 187 188/** 189 * Set the current context pointer for this thread. 190 * The context pointer is an opaque type which should be cast to 191 * void from the real context pointer type. 192 */ 193void 194u_current_set_user(const void *ptr) 195{ 196 u_current_init(); 197 198#if defined(GLX_USE_TLS) 199 u_current_user = (void *) ptr; 200#elif defined(THREADS) 201 u_tsd_set(&u_current_user_tsd, (void *) ptr); 202 u_current_user = (ThreadSafe) ? NULL : (void *) ptr; 203#else 204 u_current_user = (void *) ptr; 205#endif 206} 207 208/** 209 * Get the current context pointer for this thread. 210 * The context pointer is an opaque type which should be cast from 211 * void to the real context pointer type. 212 */ 213void * 214u_current_get_user_internal(void) 215{ 216#if defined(GLX_USE_TLS) 217 return u_current_user; 218#elif defined(THREADS) 219 return (ThreadSafe) 220 ? u_tsd_get(&u_current_user_tsd) 221 : u_current_user; 222#else 223 return u_current_user; 224#endif 225} 226 227/** 228 * Set the global or per-thread dispatch table pointer. 229 * If the dispatch parameter is NULL we'll plug in the no-op dispatch 230 * table (__glapi_noop_table). 231 */ 232void 233u_current_set(const struct mapi_table *tbl) 234{ 235 u_current_init(); 236 237 stub_init_once(); 238 239 if (!tbl) 240 tbl = (const struct mapi_table *) table_noop_array; 241 242#if defined(GLX_USE_TLS) 243 u_current_table = (struct mapi_table *) tbl; 244#elif defined(THREADS) 245 u_tsd_set(&u_current_table_tsd, (void *) tbl); 246 u_current_table = (ThreadSafe) ? NULL : (void *) tbl; 247#else 248 u_current_table = (struct mapi_table *) tbl; 249#endif 250} 251 252/** 253 * Return pointer to current dispatch table for calling thread. 254 */ 255struct mapi_table * 256u_current_get_internal(void) 257{ 258#if defined(GLX_USE_TLS) 259 return u_current_table; 260#elif defined(THREADS) 261 return (struct mapi_table *) ((ThreadSafe) ? 262 u_tsd_get(&u_current_table_tsd) : (void *) u_current_table); 263#else 264 return u_current_table; 265#endif 266} 267