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
40 #include "glapi.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
__glXSetCurrentContext(struct glx_context * c)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
init_thread_data(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
__glXSetCurrentContext(struct glx_context * c)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 *
__glXGetCurrentContext(void)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
__glXSetCurrentContextNull(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
glXGetCurrentContext(void)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
glXGetCurrentDrawable(void)162 glXGetCurrentDrawable(void)
163 {
164 struct glx_context *gc = __glXGetCurrentContext();
165 return gc->currentDrawable;
166 }
167
168 static void
__glXGenerateError(Display * dpy,XID resource,BYTE errorCode,CARD16 minorCode)169 __glXGenerateError(Display * dpy, XID resource,
170 BYTE errorCode, CARD16 minorCode)
171 {
172 xError error;
173
174 error.errorCode = errorCode;
175 error.resourceID = resource;
176 error.sequenceNumber = dpy->request;
177 error.type = X_Error;
178 error.majorCode = __glXSetupForCommand(dpy);
179 error.minorCode = minorCode;
180 _XError(dpy, &error);
181 }
182
183 /**
184 * Make a particular context current.
185 *
186 * \note This is in this file so that it can access dummyContext.
187 */
188 static Bool
MakeContextCurrent(Display * dpy,GLXDrawable draw,GLXDrawable read,GLXContext gc_user)189 MakeContextCurrent(Display * dpy, GLXDrawable draw,
190 GLXDrawable read, GLXContext gc_user)
191 {
192 struct glx_context *gc = (struct glx_context *) gc_user;
193 struct glx_context *oldGC = __glXGetCurrentContext();
194
195 /* Make sure that the new context has a nonzero ID. In the request,
196 * a zero context ID is used only to mean that we bind to no current
197 * context.
198 */
199 if ((gc != NULL) && (gc->xid == None)) {
200 return GL_FALSE;
201 }
202
203 _glapi_check_multithread();
204
205 __glXLock();
206 if (oldGC == gc &&
207 gc->currentDrawable == draw && gc->currentReadable == read) {
208 __glXUnlock();
209 return True;
210 }
211
212 if (oldGC != &dummyContext) {
213 if (--oldGC->thread_refcount == 0) {
214 oldGC->vtable->unbind(oldGC, gc);
215 oldGC->currentDpy = 0;
216 }
217 }
218
219 if (gc) {
220 /* Attempt to bind the context. We do this before mucking with
221 * gc and __glXSetCurrentContext to properly handle our state in
222 * case of an error.
223 *
224 * If an error occurs, set the Null context since we've already
225 * blown away our old context. The caller is responsible for
226 * figuring out how to handle setting a valid context.
227 */
228 if (gc->vtable->bind(gc, oldGC, draw, read) != Success) {
229 __glXSetCurrentContextNull();
230 __glXUnlock();
231 __glXGenerateError(dpy, None, GLXBadContext, X_GLXMakeContextCurrent);
232 return GL_FALSE;
233 }
234
235 if (gc->thread_refcount == 0) {
236 gc->currentDpy = dpy;
237 gc->currentDrawable = draw;
238 gc->currentReadable = read;
239 }
240 gc->thread_refcount++;
241 __glXSetCurrentContext(gc);
242 } else {
243 __glXSetCurrentContextNull();
244 }
245
246 if (oldGC->thread_refcount == 0 && oldGC != &dummyContext && oldGC->xid == None) {
247 /* We are switching away from a context that was
248 * previously destroyed, so we need to free the memory
249 * for the old handle. */
250 oldGC->vtable->destroy(oldGC);
251 }
252
253 __glXUnlock();
254
255 /* The indirect vertex array state must to be initialised after we
256 * have setup the context, as it needs to query server attributes.
257 */
258 if (gc && !gc->isDirect) {
259 __GLXattribute *state = gc->client_state_private;
260 if (state && state->array_state == NULL) {
261 glGetString(GL_EXTENSIONS);
262 glGetString(GL_VERSION);
263 __glXInitVertexArrayState(gc);
264 }
265 }
266
267 return GL_TRUE;
268 }
269
270
271 _GLX_PUBLIC Bool
glXMakeCurrent(Display * dpy,GLXDrawable draw,GLXContext gc)272 glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
273 {
274 return MakeContextCurrent(dpy, draw, draw, gc);
275 }
276
277 _GLX_PUBLIC
278 GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
279 (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
280 (dpy, d, r, ctx), MakeContextCurrent)
281
282 _GLX_PUBLIC
283 GLX_ALIAS(Bool, glXMakeContextCurrent,
284 (Display * dpy, GLXDrawable d, GLXDrawable r,
285 GLXContext ctx), (dpy, d, r, ctx), MakeContextCurrent)
286