Convert GLX module to use screen private indexes like everything else.

GL/glx/glxcmds.c

@@ -131,8 +131,8 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
 	return BadValue;
     }
     pScreen = screenInfo.screens[screen];
-    pGlxScreen = __glXActiveScreens[screen];
+    pGlxScreen = glxGetScreen(pScreen);
-    
+
     /*
     ** Check if the visual ID is valid for this screen.
     */
@@ -149,7 +149,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
 
     /*
     ** Get configuration of the visual.  This assumes that the
-    ** glXActiveScreens structure contains visual configurations only for the
+    ** glxScreen structure contains visual configurations only for the
     ** subset of Visuals that are supported by this implementation of the
     ** OpenGL.
     */
@@ -931,7 +931,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
 	client->errorValue = screen;
 	return BadValue;
     }
-    pGlxScreen = __glXActiveScreens[screen];
+    pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
 
     reply.numVisuals = pGlxScreen->numUsableVisuals;
     reply.numProps = __GLX_TOTAL_CONFIG;
@@ -1119,7 +1119,7 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
 	client->errorValue = screen;
 	return BadValue;
     }
-    pGlxScreen = __glXActiveScreens[screen];
+    pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
 
     /* Create the "extra" 32bpp ARGB visual, if not already added.
      * XXX This is questionable place to do so!  Re-examine this someday.
@@ -1245,7 +1245,7 @@ static int ValidateCreateDrawable(ClientPtr client,
     }
 
     /* Get configuration of the visual. */
-    pGlxScreen = __glXgetActiveScreen(screenNum);
+    pGlxScreen = glxGetScreen(pScreen);
     *modes = _gl_context_modes_find_visual(pGlxScreen->modes, fbconfigId);
     if (*modes == NULL) {
 	/* Visual not support on this screen by this OpenGL implementation. */
@@ -1286,7 +1286,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
 	return BadAlloc;
     }
     pGlxPixmap->pDraw = pDraw;
-    pGlxPixmap->pGlxScreen = __glXgetActiveScreen(screenNum);
+    pGlxPixmap->pGlxScreen = glxGetScreen(pDraw->pScreen);
     pGlxPixmap->pScreen = pDraw->pScreen;
     pGlxPixmap->idExists = True;
 #ifdef XF86DRI
@@ -1430,7 +1430,7 @@ int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
     /* FIXME: We need to check that the window visual is compatible
      * with the specified fbconfig. */
 
-    screen = __glXgetActiveScreen(req->screen);
+    screen = glxGetScreen(screenInfo.screens[req->screen]);
     glxPriv = screen->createDrawable(screen, pDraw, req->glxwindow, modes);
     if (glxPriv == NULL)
 	return BadAlloc;
@@ -2368,7 +2368,7 @@ int __glXDisp_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
 	return BadValue;
     }
 
-    ptr = __glXActiveScreens[screen]->GLXextensions;
+    ptr = glxGetScreen(screenInfo.screens[screen])->GLXextensions;
 
     n = strlen(ptr) + 1;
     length = __GLX_PAD(n) >> 2;
@@ -2404,6 +2404,7 @@ int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
     size_t n, length;
     const char *ptr;
     char *buf;
+    __GLXscreen *pGlxScreen;
 
     name = req->name;
     screen = req->screen;
@@ -2414,15 +2415,17 @@ int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
 	client->errorValue = screen;
 	return BadValue;
     }
+    pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+
     switch(name) {
 	case GLX_VENDOR:
-	    ptr = __glXActiveScreens[screen]->GLXvendor;
+	    ptr = pGlxScreen->GLXvendor;
 	    break;
 	case GLX_VERSION:
-	    ptr = __glXActiveScreens[screen]->GLXversion;
+	    ptr = pGlxScreen->GLXversion;
 	    break;
 	case GLX_EXTENSIONS:
-	    ptr = __glXActiveScreens[screen]->GLXextensions;
+	    ptr = pGlxScreen->GLXextensions;
 	    break;
 	default:
 	    return BadValue; 

GL/glx/glxdri.c

@@ -103,7 +103,7 @@ __glXDRIleaveServer(GLboolean rendering)
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
 	__GLXDRIscreen * const screen =
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
 	GLuint lastOverride = screen->lastTexOffsetOverride;
 
 	if (lastOverride) {
@@ -125,7 +125,7 @@ __glXDRIleaveServer(GLboolean rendering)
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
 	__GLXDRIscreen * const screen =
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
 	GLuint lastOverride = screen->lastTexOffsetOverride;
 
 	if (lastOverride) {
@@ -153,8 +153,8 @@ __glXDRIenterServer(GLboolean rendering)
     int i;
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
-	__GLXDRIscreen * const screen =
+	__GLXDRIscreen * const screen = (__GLXDRIscreen *)
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    glxGetScreen(screenInfo.screens[i]);
 
 	if (screen->lastTexOffsetOverride) {
 	    CALL_Flush(GET_DISPATCH(), ());
@@ -205,7 +205,7 @@ __glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
 {
     __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
     __GLXDRIscreen *screen = (__GLXDRIscreen *)
-	__glXgetActiveScreen(baseDrawable->pDraw->pScreen->myNum);
+	glxGetScreen(baseDrawable->pDraw->pScreen);
 
     if (screen->swapControl)
 	screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
@@ -220,7 +220,7 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
     __GLXDRIscreen *screen = (__GLXDRIscreen *)
-	__glXgetActiveScreen(basePrivate->pDraw->pScreen->myNum);
+	glxGetScreen(basePrivate->pDraw->pScreen);
 
     if (screen->copySubBuffer)
 	screen->copySubBuffer->copySubBuffer(&private->driDrawable,
@@ -328,8 +328,7 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
     int		bpp, override = 0, texname;
     GLenum	format, type;
     ScreenPtr pScreen = glxPixmap->pScreen;
-    __GLXDRIscreen * const screen =
+    __GLXDRIscreen * const screen = (__GLXDRIscreen *) glxGetScreen(pScreen);
-	(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
 
     CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
 				      GL_TEXTURE_BINDING_2D :
@@ -482,7 +481,7 @@ __glXDRIreleaseTexImage(__GLXcontext *baseContext,
 {
     ScreenPtr pScreen = pixmap->pScreen;
     __GLXDRIscreen * const screen =
-	(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
+	(__GLXDRIscreen *) glxGetScreen(pScreen);
     GLuint lastOverride = screen->lastTexOffsetOverride;
 
     if (lastOverride) {
@@ -801,7 +800,8 @@ static const char dri_driver_path[] = DRI_DRIVER_PATH;
 static Bool
 glxDRIEnterVT (int index, int flags)
 {
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+    __GLXDRIscreen *screen = (__GLXDRIscreen *) 
+	glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
 
@@ -816,7 +816,8 @@ glxDRIEnterVT (int index, int flags)
 static void
 glxDRILeaveVT (int index, int flags)
 {
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+	glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
 

GL/glx/glxext.c

@@ -45,7 +45,6 @@ __GLXcontext *__glXLastContext;
 ** X resources.
 */
 RESTYPE __glXContextRes;
-RESTYPE __glXClientRes;
 RESTYPE __glXPixmapRes;
 RESTYPE __glXDrawableRes;
 RESTYPE __glXSwapBarrierRes;
@@ -55,11 +54,7 @@ RESTYPE __glXSwapBarrierRes;
 */
 xGLXSingleReply __glXReply;
 
-/*
+static int glxClientPrivateIndex;
-** A set of state for each client.  The 0th one is unused because client
-** indices start at 1, not 0.
-*/
-static __GLXclientState *__glXClients[MAXCLIENTS + 1];
 
 /*
 ** Client that called into GLX dispatch.
@@ -77,29 +72,6 @@ static int __glXDispatch(ClientPtr);
 static void ResetExtension(ExtensionEntry* extEntry)
 {
     __glXFlushContextCache();
-    __glXResetScreens();
-}
-
-/*
-** Initialize the per-client context storage.
-*/
-static void ResetClientState(int clientIndex)
-{
-    __GLXclientState *cl = __glXClients[clientIndex];
-
-    if (cl->returnBuf) xfree(cl->returnBuf);
-    if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
-    if (cl->currentContexts) xfree(cl->currentContexts);
-    memset(cl, 0, sizeof(__GLXclientState));
-    /*
-    ** By default, assume that the client supports
-    ** GLX major version 1 minor version 0 protocol.
-    */
-    cl->GLClientmajorVersion = 1;
-    cl->GLClientminorVersion = 0;
-    if (cl->GLClientextensions)
-	xfree(cl->GLClientextensions);
-
 }
 
 /*
@@ -129,39 +101,6 @@ static int ContextGone(__GLXcontext* cx, XID id)
     return True;
 }
 
-/*
-** Free a client's state.
-*/
-static int ClientGone(int clientIndex, XID id)
-{
-    __GLXcontext *cx;
-    __GLXclientState *cl = __glXClients[clientIndex];
-    int i;
-
-    if (cl) {
-	/*
-	** Free all the contexts that are current for this client.
-	*/
-	for (i=0; i < cl->numCurrentContexts; i++) {
-	    cx = cl->currentContexts[i];
-	    if (cx) {
-		cx->isCurrent = GL_FALSE;
-		if (!cx->idExists) {
-		    __glXFreeContext(cx);
-		}
-	    }
-	}
-	/*
-	** Re-initialize the client state structure.  Don't free it because
-	** we'll probably get another client with this index and use the struct
-	** again.  There is a maximum of MAXCLIENTS of these structures.
-	*/
-	ResetClientState(clientIndex);
-    }
-
-    return True;
-}
-
 /*
 ** Free a GLX Pixmap.
 */
@@ -309,22 +248,87 @@ int __glXError(int error)
     return __glXErrorBase + error;
 }
 
+__GLXclientState *
+glxGetClient(ClientPtr pClient)
+{
+    return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
+}
+
+static void
+glxClientCallback (CallbackListPtr	*list,
+		   pointer		closure,
+		   pointer		data)
+{
+    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
+    ClientPtr		pClient = clientinfo->client;
+    __GLXclientState	*cl = glxGetClient(pClient);
+    __GLXcontext	*cx;
+    int i;
+
+    switch (pClient->clientState) {
+    case ClientStateRunning:
+	/*
+	** By default, assume that the client supports
+	** GLX major version 1 minor version 0 protocol.
+	*/
+	cl->GLClientmajorVersion = 1;
+	cl->GLClientminorVersion = 0;
+	cl->client = pClient;
+	break;
+
+    case ClientStateGone:
+	for (i = 0; i < cl->numCurrentContexts; i++) {
+	    cx = cl->currentContexts[i];
+	    if (cx) {
+		cx->isCurrent = GL_FALSE;
+		if (!cx->idExists)
+		    __glXFreeContext(cx);
+	    }
+	}
+
+	if (cl->returnBuf) xfree(cl->returnBuf);
+	if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
+	if (cl->currentContexts) xfree(cl->currentContexts);
+	if (cl->GLClientextensions) xfree(cl->GLClientextensions);
+	break;
+
+    default:
+	break;
+    }
+}
+
 /************************************************************************/
 
+static __GLXprovider *__glXProviderStack;
+
+void GlxPushProvider(__GLXprovider *provider)
+{
+    provider->next = __glXProviderStack;
+    __glXProviderStack = provider;
+}
+
 /*
 ** Initialize the GLX extension.
 */
 void GlxExtensionInit(void)
 {
     ExtensionEntry *extEntry;
+    ScreenPtr pScreen;
     int i;
+    __GLXprovider *p;
 
     __glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
-    __glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
     __glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
     __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
     __glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
 
+    glxClientPrivateIndex = AllocateClientPrivateIndex ();
+    if (!AllocateClientPrivate (glxClientPrivateIndex,
+				sizeof (__GLXclientState)))
+	return;
+    if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
+	return;
+
     /*
     ** Add extension to server extensions.
     */
@@ -343,17 +347,17 @@ void GlxExtensionInit(void)
 
     __glXErrorBase = extEntry->errorBase;
 
-    /*
+    for (i = 0; i < screenInfo.numScreens; i++) {
-    ** Initialize table of client state.  There is never a client 0.
+	pScreen = screenInfo.screens[i];
-    */
-    for (i = 1; i <= MAXCLIENTS; i++) {
-	__glXClients[i] = 0;
-    }
 
-    /*
+	for (p = __glXProviderStack; p != NULL; p = p->next) {
-    ** Initialize screen specific data.
+	    if (p->screenProbe(pScreen) != NULL)
-    */
+		LogMessage(X_INFO,
-    __glXInitScreens();
+			   "GLX: Initialized %s GL provider for screen %d\n",
+			   p->name, i);
+	    break;
+	}
+    }
 }
 
 /************************************************************************/
@@ -421,11 +425,9 @@ void glxSuspendClients(void)
 {
     int i;
 
-    for (i = 1; i <= MAXCLIENTS; i++) {
+    for (i = 1; i < currentMaxClients; i++) {
-	if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
+	if (glxGetClient(clients[i])->inUse)
-	    continue;
+	    IgnoreClient(clients[i]);
-
-	IgnoreClient(__glXClients[i]->client);
     }
 
     glxBlockClients = TRUE;
@@ -438,11 +440,9 @@ void glxResumeClients(void)
 
     glxBlockClients = FALSE;
 
-    for (i = 1; i <= MAXCLIENTS; i++) {
+    for (i = 1; i < currentMaxClients; i++) {
-	if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
+	if (glxGetClient(clients[i])->inUse)
-	    continue;
+	    AttendClient(clients[i]);
-
-	AttendClient(__glXClients[i]->client);
     }
 
     __glXleaveServer(GL_FALSE);
@@ -504,29 +504,9 @@ static int __glXDispatch(ClientPtr client)
     int retval;
 
     opcode = stuff->glxCode;
-    cl = __glXClients[client->index];
+    cl = glxGetClient(client);
-    if (!cl) {
+    /* Mark it in use so we suspend it on VT switch. */
-	cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
+    cl->inUse = TRUE;
-	 __glXClients[client->index] = cl;
-	if (!cl) {
-	    return BadAlloc;
-	}
-	memset(cl, 0, sizeof(__GLXclientState));
-    }
-    
-    if (!cl->inUse) {
-	/*
-	** This is first request from this client.  Associate a resource
-	** with the client so we will be notified when the client dies.
-	*/
-	XID xid = FakeClientID(client->index);
-	if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
-	    return BadAlloc;
-	}
-	ResetClientState(client->index);
-	cl->inUse = GL_TRUE;
-	cl->client = client;
-    }
 
     /*
     ** If we're expecting a glXRenderLarge request, this better be one.

GL/glx/glxscreens.c

@@ -45,6 +45,8 @@
 #include "glxutil.h"
 #include "glxext.h"
 
+static int glxScreenPrivateIndex;
+
 const char GLServerVersion[] = "1.4";
 static const char GLServerExtensions[] = 
 			"GL_ARB_depth_texture "
@@ -179,36 +181,31 @@ static char GLXServerExtensions[] =
 			"GLX_MESA_copy_sub_buffer "
 			;
 
-__GLXscreen **__glXActiveScreens;
-
 __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
 static int __glXNumSwapBarrierFuncs = 0;
 __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
 static int __glXNumHyperpipeFuncs = 0;
 
-__GLXscreen *__glXgetActiveScreen(int num) {
-	return __glXActiveScreens[num];
-}
-
 
 /*
 ** This hook gets called when a window moves or changes size.
 */
-static Bool PositionWindow(WindowPtr pWin, int x, int y)
+static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
 {
     ScreenPtr pScreen;
     __GLXcontext *glxc;
     __GLXdrawable *glxPriv;
     Bool ret;
+    __GLXscreen *pGlxScreen;
 
     /*
     ** Call wrapped position window routine
     */
     pScreen = pWin->drawable.pScreen;
-    pScreen->PositionWindow =
+    pGlxScreen = glxGetScreen(pScreen);
-	__glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
+    pScreen->PositionWindow = pGlxScreen->PositionWindow;
     ret = (*pScreen->PositionWindow)(pWin, x, y);
-    pScreen->PositionWindow = PositionWindow;
+    pScreen->PositionWindow = glxPositionWindow;
 
     /*
     ** Tell all contexts rendering into this window that the window size
@@ -289,80 +286,59 @@ void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
         funcs->queryMaxSwapBarriersFunc;
 }
 
-static __GLXprovider *__glXProviderStack;
+static Bool
-
+glxCloseScreen (int index, ScreenPtr pScreen)
-void GlxPushProvider(__GLXprovider *provider)
 {
-    provider->next = __glXProviderStack;
+    __GLXscreen *pGlxScreen = glxGetScreen(pScreen);
-    __glXProviderStack = provider;
+
+    pScreen->CloseScreen = pGlxScreen->CloseScreen;
+    pScreen->PositionWindow = pGlxScreen->PositionWindow;
+
+    pGlxScreen->destroy(pGlxScreen);
+
+    return pScreen->CloseScreen(index, pScreen);
 }
 
-void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
+__GLXscreen *
+glxGetScreen(ScreenPtr pScreen)
 {
-    screen->pScreen       = pScreen;
+    return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
-    screen->GLextensions  = xstrdup(GLServerExtensions);
-    screen->GLXvendor     = xstrdup(GLXServerVendorName);
-    screen->GLXversion    = xstrdup(GLXServerVersion);
-    screen->GLXextensions = xstrdup(GLXServerExtensions);
-
-    screen->WrappedPositionWindow = pScreen->PositionWindow;
-    pScreen->PositionWindow = PositionWindow;
-
-    __glXScreenInitVisuals(screen);
 }
 
-void
+void __glXScreenInit(__GLXscreen *glxScreen, ScreenPtr pScreen)
-__glXScreenDestroy(__GLXscreen *screen)
+{
+    static int glxGeneration;
+
+    if (glxGeneration != serverGeneration)
+    {
+	glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
+	if (glxScreenPrivateIndex == -1)
+	    return;
+
+	glxGeneration = serverGeneration;
+    }
+
+    glxScreen->pScreen       = pScreen;
+    glxScreen->GLextensions  = xstrdup(GLServerExtensions);
+    glxScreen->GLXvendor     = xstrdup(GLXServerVendorName);
+    glxScreen->GLXversion    = xstrdup(GLXServerVersion);
+    glxScreen->GLXextensions = xstrdup(GLXServerExtensions);
+
+    glxScreen->PositionWindow = pScreen->PositionWindow;
+    pScreen->PositionWindow = glxPositionWindow;
+ 
+    glxScreen->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = glxCloseScreen;
+
+    __glXScreenInitVisuals(glxScreen);
+
+    pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) glxScreen;
+}
+ 
+void __glXScreenDestroy(__GLXscreen *screen)
 {
     xfree(screen->GLXvendor);
     xfree(screen->GLXversion);
     xfree(screen->GLXextensions);
     xfree(screen->GLextensions);
 }
-
-void __glXInitScreens(void)
-{
-    GLint i;
-    ScreenPtr pScreen;
-    __GLXprovider *p;
-    size_t size;
-
-    /*
-    ** This alloc has to work or else the server might as well core dump.
-    */
-    size = screenInfo.numScreens * sizeof(__GLXscreen *);
-    __glXActiveScreens = xalloc(size);
-    memset(__glXActiveScreens, 0, size);
-    
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	pScreen = screenInfo.screens[i];
-
-	for (p = __glXProviderStack; p != NULL; p = p->next) {
-	    __glXActiveScreens[i] = p->screenProbe(pScreen);
-	    if (__glXActiveScreens[i] != NULL) {
-		LogMessage(X_INFO,
-			   "GLX: Initialized %s GL provider for screen %d\n",
-			   p->name, i);
-	        break;
-	    }
-	}
-    }
-}
-
-void __glXResetScreens(void)
-{
-  int i;
-
-  for (i = 0; i < screenInfo.numScreens; i++)
-      if (__glXActiveScreens[i])
-	  __glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
-
-    xfree(__glXActiveScreens);
-    xfree(__glXHyperpipeFuncs);
-    xfree(__glXSwapBarrierFuncs);
-    __glXNumHyperpipeFuncs = 0;
-    __glXNumSwapBarrierFuncs = 0;
-    __glXHyperpipeFuncs = NULL;
-    __glXSwapBarrierFuncs = NULL;
-    __glXActiveScreens = NULL;
-}

GL/glx/glxscreens.h

@@ -79,18 +79,12 @@ struct __GLXscreen {
     char *GLXversion;
     char *GLXextensions;
 
-    /*
+    Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
-    ** Things that are not statically set.
+    Bool (*CloseScreen)(int index, ScreenPtr pScreen);
-    */
-    Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
-
 };
 
 
 void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
 void __glXScreenDestroy(__GLXscreen *screen);
 
-void __glXInitScreens(void);
-extern void __glXResetScreens(void);
-
 #endif /* !__GLX_screens_h__ */

GL/glx/glxserver.h

@@ -90,9 +90,8 @@ typedef XID GLXDrawable;
 
 typedef struct __GLXclientStateRec __GLXclientState;
 
-extern __GLXscreen **__glXActiveScreens;
+extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
-extern GLint __glXNumActiveScreens;
+extern __GLXclientState *glxGetClient(ClientPtr pClient);
-extern __GLXscreen *__glXgetActiveScreen(int num);
 
 /************************************************************************/
 

hw/xfree86/dri/dri.c

@@ -972,7 +972,7 @@ static Bool
 DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
-    __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
+    __GLXscreen *pGLXScreen = glxGetScreen(pScreen);
     __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;
@@ -1036,7 +1036,7 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
                  XID context, drm_context_t * pHWContext)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
-    __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
+    __GLXscreen *pGLXScreen = glxGetScreen(pScreen);
     __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;