picnoir/libglvnd
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
libglvnd/src/GLX/libglxmapping.c

969 lines
28 KiB
C
Raw Normal View History

Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
/*
* Copyright (c) 2013, NVIDIA CORPORATION.
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* unaltered in all copies or substantial portions of the Materials.
* Any additions, deletions, or changes to the original source files
* must be clearly indicated in accompanying documentation.
*
* If only executable code is distributed, then the accompanying
* documentation must state that "this software is based in part on the
* work of the Khronos Group."
*
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
*/
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
#include <X11/Xlibint.h>
#include <pthread.h>
#include <dlfcn.h>
#if defined(HASH_DEBUG)
# include <stdio.h>
#endif
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
#include "libglxcurrent.h"
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
#include "libglxmapping.h"
#include "libglxnoop.h"
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
#include "libglxthread.h"
More fixes for glXGetClientString. glXGetClientString will now allocate a buffer for the string and will merge the strings from multiple vendor libraries. For GLX_VENDOR, it will return each vendor library's string, separated by commas. For GLX_VERSION, it will report the highest version number of any vendor library, up to the GLX version that libglvnd itself supports (currently 1.4). For GLX_EXTENSIONS, it will return the union of all extensions advertised by all vendor libraries.
2015-04-13 21:38:35 +02:00
#include "libglxstring.h"
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
#include "trace.h"
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
#include "lkdhash.h"
Add x11glvnd X11 extension This will be used to handle the corner case when a drawable XID is passed into the API library which belongs to an X window or otherwise has never been seen before by the process, by providing a way to lookup which screen the corresponding drawable belongs. This still is racey since we can't guarantee a different process won't free the XID and cause it to be recycled as a handle for a different resource after the lookup, but better than not being able to figure out the mapping at all. This extension also solves the less-difficult problem of mapping a screen to a vendor name (though it may make more sense to at some point directly map drawables to a vendor to better support render-offload scenarios).
2013-08-12 22:12:09 +02:00
#include "x11glvnd.h"
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
#define _GNU_SOURCE 1
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
/*
* Hash table containing a mapping from dispatch table index entries to
* entry point names. This is used in __glXFetchDispatchEntry() to query
* the appropriate vendor in the case where the entry hasn't been seen before
* by this vendor.
*/
typedef struct __GLXdispatchIndexHashRec {
int index;
GLubyte *procName;
UT_hash_handle hh;
} __GLXdispatchIndexHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXdispatchIndexHash, __glXDispatchIndexHash);
/*
* Monotonically-increasing number describing both the virtual "size" of the
* dynamic dispatch table and the next unused index. Must be accessed holding
* the __glXDispatchIndexHash lock.
*/
static int __glXNextUnusedHashIndex;
typedef struct __GLXdispatchFuncHashRec {
int index;
__GLXextFuncPtr addr;
UT_hash_handle hh;
} __GLXdispatchFuncHash;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
struct __GLXdispatchTableDynamicRec {
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
/*
* Hash table containing the dynamic dispatch funcs. This is used instead of
* a flat array to avoid sparse array usage. XXX might be more performant to
* use an array, though?
*/
DEFINE_LKDHASH(__GLXdispatchFuncHash, hash);
/*
* Pointer to the vendor library info, used by __glXFetchDispatchEntry()
*/
__GLXvendorInfo *vendor;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
};
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
/****************************************************************************/
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
/*
* __glXVendorScreenHash is a hash table which maps a Display+screen to a vendor.
* Look up this mapping from the X server once, the first time a unique
* Display+screen pair is seen.
*/
typedef struct {
Display *dpy;
int screen;
} __GLXvendorScreenHashKey;
typedef struct __GLXvendorScreenHashRec {
__GLXvendorScreenHashKey key;
__GLXvendorInfo *vendor;
// XXX for performance reasons we may want to stash the dispatch tables here
// as well
UT_hash_handle hh;
} __GLXvendorScreenHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXvendorScreenHash, __glXVendorScreenHash);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
/*
* __glXVendorNameHash is a hash table mapping a vendor name to vendor info.
*/
typedef struct __GLXvendorNameHashRec {
const char *name;
__GLXvendorInfo *vendor;
UT_hash_handle hh;
} __GLXvendorNameHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXvendorNameHash, __glXVendorNameHash);
Change glXGetClientString strings to be per-display. Add a hashtable for keeping track of per-display data and move the client strings into that table.
2015-04-14 19:58:43 +02:00
typedef struct __GLXdisplayInfoHashRec {
Display *dpy;
__GLXdisplayInfo info;
UT_hash_handle hh;
} __GLXdisplayInfoHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXdisplayInfoHash, __glXDisplayInfoHash);
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
static GLboolean AllocDispatchIndex(__GLXvendorInfo *vendor,
const GLubyte *procName)
{
__GLXdispatchIndexHash *pEntry = malloc(sizeof(*pEntry));
if (!pEntry) {
return GL_FALSE;
}
pEntry->procName = (GLubyte *)strdup((const char *)procName);
Check strdup(3) return value in AllocDispatchIndex() Signed-off-by: Andy Ritger <aritger@nvidia.com> Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-09-04 06:57:16 +02:00
if (!pEntry->procName) {
free(pEntry);
return GL_FALSE;
}
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
pEntry->index = __glXNextUnusedHashIndex++;
// Notify the vendor this is the index which should be used
vendor->staticDispatch->
glxvc.setDispatchIndex(procName, pEntry->index);
HASH_ADD_INT(_LH(__glXDispatchIndexHash),
index, pEntry);
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
return GL_TRUE;
}
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
/*!
* Callback function used when freeing the dispatch index hash table.
*/
static void CleanupDispatchIndexEntry(void *unused, __GLXdispatchIndexHash *pEntry)
{
assert(pEntry);
free(pEntry->procName);
}
/*!
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
* This function queries each loaded vendor to determine if there is
* a vendor-implemented dispatch function. The dispatch function
* uses the vendor <-> API library ABI to determine the screen given
* the parameters of the function and dispatch to the correct vendor's
* implementation.
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
*/
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXextFuncPtr __glXGetGLXDispatchAddress(const GLubyte *procName)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
__GLXextFuncPtr addr = NULL;
__GLXvendorNameHash *pEntry, *tmp;
/*
* XXX for full correctness, we should probably load vendors
* on all screens up-front before doing this. However, that
* might be bad for performance?
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
*
* A better way to solve this issue might be to tweak the ABI slightly
* to allow vendors to provide a standalone DSO which only
* exports vendor-neutral dispatch functions, and nothing else.
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
*/
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXVendorNameHash);
HASH_ITER(hh, _LH(__glXVendorNameHash), pEntry, tmp) {
// See if the current vendor supports this GLX entry point
addr = pEntry->vendor->staticDispatch->
glxvc.getDispatchAddress(procName);
if (addr) {
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
// Allocate the new dispatch index.
if (!AllocDispatchIndex(pEntry->vendor, procName)) {
addr = NULL;
}
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
break;
}
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorNameHash);
return addr;
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
__GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor,
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
int index)
{
__GLXextFuncPtr addr = NULL;
__GLXdispatchFuncHash *pEntry;
GLubyte *procName = NULL;
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
__GLXdispatchTableDynamic *dynDispatch = vendor->dynDispatch;
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
LKDHASH_RDLOCK(__glXPthreadFuncs, dynDispatch->hash);
HASH_FIND_INT(_LH(dynDispatch->hash), &index, pEntry);
if (pEntry) {
// This can be NULL, which indicates the vendor does not implement this
// entry. Vendor library provided dispatch functions are expected to
// default to a no-op in case dispatching fails.
addr = pEntry->addr;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, dynDispatch->hash);
if (!pEntry) {
// Not seen before by this vendor: query the vendor for the right
// address to use.
__GLXdispatchIndexHash *pdiEntry;
// First retrieve the procname of this index
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
HASH_FIND_INT(_LH(__glXDispatchIndexHash), &index, pdiEntry);
procName = pdiEntry->procName;
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
// This should have a valid entry point associated with it.
assert(procName);
if (procName) {
// Get the real address
addr = dynDispatch->vendor->staticDispatch->
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
glxvc.getProcAddress(procName, GL_FALSE);
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
}
LKDHASH_WRLOCK(__glXPthreadFuncs, dynDispatch->hash);
HASH_FIND_INT(_LH(dynDispatch->hash), &index, pEntry);
if (!pEntry) {
pEntry = malloc(sizeof(*pEntry));
if (!pEntry) {
// Uh-oh!
assert(pEntry);
Unlock in the __glXFetchDispatchEntry() failure path. Signed-off-by: Andy Ritger <aritger@nvidia.com> Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-09-04 06:55:54 +02:00
LKDHASH_UNLOCK(__glXPthreadFuncs, dynDispatch->hash);
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
return NULL;
}
pEntry->index = index;
pEntry->addr = addr;
HASH_ADD_INT(_LH(dynDispatch->hash), index, pEntry);
} else {
addr = pEntry->addr;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, dynDispatch->hash);
}
return addr;
}
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
static __GLXapiExports glxExportsTable;
static glvnd_once_t glxExportsTableOnceControl = GLVND_ONCE_INIT;
static void InitExportsTable(void)
{
glxExportsTable.getDynDispatch = __glXGetDynDispatch;
glxExportsTable.getCurrentDynDispatch = __glXGetCurrentDynDispatch;
glxExportsTable.fetchDispatchEntry = __glXFetchDispatchEntry;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
/* We use the real function since __glXGetCurrentContext is inline */
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
glxExportsTable.getCurrentContext = glXGetCurrentContext;
glxExportsTable.addScreenContextMapping = __glXAddScreenContextMapping;
glxExportsTable.removeScreenContextMapping = __glXRemoveScreenContextMapping;
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
glxExportsTable.vendorFromContext = __glXVendorFromContext;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
glxExportsTable.addScreenFBConfigMapping = __glXAddScreenFBConfigMapping;
glxExportsTable.removeScreenFBConfigMapping = __glXRemoveScreenFBConfigMapping;
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
glxExportsTable.vendorFromFBConfig = __glXVendorFromFBConfig;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
libGLX: Add visual to vendor mappings. Add functions to __GLXapiExports to manage mappings from an XVisualInfo to a vendor. This should allow the same sort of arbitrary vendor selection for the GLX 1.2 XVisualInfo-based functions as for the GLXFBConfig-based ones.
2015-04-20 22:29:07 +02:00
glxExportsTable.addScreenVisualMapping = __glXAddScreenVisualMapping;
glxExportsTable.removeScreenVisualMapping = __glXRemoveScreenVisualMapping;
glxExportsTable.vendorFromVisual = __glXVendorFromVisual;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
glxExportsTable.addScreenDrawableMapping = __glXAddScreenDrawableMapping;
glxExportsTable.removeScreenDrawableMapping = __glXRemoveScreenDrawableMapping;
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
glxExportsTable.vendorFromDrawable = __glXVendorFromDrawable;
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
}
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
Build fixes, mostly for old systems and compilers. - Add a config check for ((constructor)) and ((destructor)) funciton attributes. - Add missing GL/glxmd.h header. - For sufficiently old gcc versions, revert to inline asm implementations of Atomic{Increment,Swap,CompareAndSwap}() - Add a local implementation of asprintf. - entry_x86_tsd.h: Add missing cast to (char *) in entry_get_public - glvnd_pthread.[ch]: Only use pthread_rwlock_t if it's available, and fall back to pthread_mutex_t otherwise. - trace.c: Add missing _GNU_SOURCE define - uthash.h: Fix a -Wcast-qual warning - x11glvndclient.c: Fix a -Wcast-qual warning by using a writable array for storing the XGLV_EXTENSION_NAME Based on a patch by Brian Nguyen.
2015-03-27 18:38:58 +01:00
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
static char *ConstructVendorLibraryFilename(const char *vendorName)
{
char *filename;
int ret;
Build fixes, mostly for old systems and compilers. - Add a config check for ((constructor)) and ((destructor)) funciton attributes. - Add missing GL/glxmd.h header. - For sufficiently old gcc versions, revert to inline asm implementations of Atomic{Increment,Swap,CompareAndSwap}() - Add a local implementation of asprintf. - entry_x86_tsd.h: Add missing cast to (char *) in entry_get_public - glvnd_pthread.[ch]: Only use pthread_rwlock_t if it's available, and fall back to pthread_mutex_t otherwise. - trace.c: Add missing _GNU_SOURCE define - uthash.h: Fix a -Wcast-qual warning - x11glvndclient.c: Fix a -Wcast-qual warning by using a writable array for storing the XGLV_EXTENSION_NAME Based on a patch by Brian Nguyen.
2015-03-27 18:38:58 +01:00
ret = glvnd_asprintf(&filename, "libGLX_%s.so.0", vendorName);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
if (ret < 0) {
return NULL;
}
return filename;
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
void TeardownVendor(__GLXvendorInfo *vendor, Bool doLibraryUnload)
{
free(vendor->name);
if (vendor->glDispatch) {
__glDispatchDestroyTable(vendor->glDispatch);
}
/* Clean up the dynamic dispatch table */
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXdispatchFuncHash,
vendor->dynDispatch->hash, NULL, NULL, True);
free(vendor->dynDispatch);
if (doLibraryUnload) {
dlclose(vendor->dlhandle);
}
free(vendor);
}
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXvendorInfo *__glXLookupVendorByName(const char *vendorName)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
__GLXvendorNameHash *pEntry = NULL;
void *dlhandle = NULL;
__PFNGLXMAINPROC glxMainProc;
const __GLXdispatchTableStatic *dispatch;
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
__GLXdispatchTableDynamic *dynDispatch;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
__GLXvendorInfo *vendor = NULL;
Bool locked = False;
Register vendors with GLdispatch This implements the notion of a "vendor ID" that is unique to each vendor library instance loaded in a process. When entrypoint rewriting is implemented, this will be used by libglvnd to determine whether a given entrypoint implementation is compatible with a given context, by comparing the vendor owning the context with the vendor owning the implementation. This changes the function prototype of __glDispatchMakeCurrent() to include the vendorID as an argument, which will be saved off in the API state, and return a boolean value to indicate whether make current succeeded.
2014-01-24 04:51:49 +01:00
int vendorID = -1;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXVendorNameHash);
HASH_FIND(hh, _LH(__glXVendorNameHash), vendorName, strlen(vendorName), pEntry);
if (pEntry) {
vendor = pEntry->vendor;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorNameHash);
if (!pEntry) {
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXVendorNameHash);
locked = True;
// Do another lookup to check uniqueness
HASH_FIND(hh, _LH(__glXVendorNameHash), vendorName, strlen(vendorName), pEntry);
if (!pEntry) {
Don't pass a NULL filename into dlopen(3). Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:05 +02:00
char *filename;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
// Previously unseen vendor. dlopen() the new vendor and add it to the
// hash table.
pEntry = calloc(1, sizeof(*pEntry));
if (!pEntry) {
goto fail;
}
filename = ConstructVendorLibraryFilename(vendorName);
Don't pass a NULL filename into dlopen(3). Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:05 +02:00
if (filename) {
dlhandle = dlopen(filename, RTLD_LAZY);
}
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
free(filename);
if (!dlhandle) {
goto fail;
}
glxMainProc = dlsym(dlhandle, __GLX_MAIN_PROTO_NAME);
if (!glxMainProc) {
goto fail;
}
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
/* Initialize the glxExportsTable if we haven't already */
__glXPthreadFuncs.once(&glxExportsTableOnceControl,
InitExportsTable);
Register vendors with GLdispatch This implements the notion of a "vendor ID" that is unique to each vendor library instance loaded in a process. When entrypoint rewriting is implemented, this will be used by libglvnd to determine whether a given entrypoint implementation is compatible with a given context, by comparing the vendor owning the context with the vendor owning the implementation. This changes the function prototype of __glDispatchMakeCurrent() to include the vendorID as an argument, which will be saved off in the API state, and return a boolean value to indicate whether make current succeeded.
2014-01-24 04:51:49 +01:00
vendorID = __glDispatchNewVendorID();
assert(vendorID >= 0);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
dispatch = (*glxMainProc)(GLX_VENDOR_ABI_VERSION,
&glxExportsTable,
Register vendors with GLdispatch This implements the notion of a "vendor ID" that is unique to each vendor library instance loaded in a process. When entrypoint rewriting is implemented, this will be used by libglvnd to determine whether a given entrypoint implementation is compatible with a given context, by comparing the vendor owning the context with the vendor owning the implementation. This changes the function prototype of __glDispatchMakeCurrent() to include the vendorID as an argument, which will be saved off in the API state, and return a boolean value to indicate whether make current succeeded.
2014-01-24 04:51:49 +01:00
vendorName,
vendorID);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
if (!dispatch) {
goto fail;
}
vendor = pEntry->vendor
= calloc(1, sizeof(__GLXvendorInfo));
if (!vendor) {
goto fail;
}
pEntry->name = vendor->name = strdup(vendorName);
Register vendors with GLdispatch This implements the notion of a "vendor ID" that is unique to each vendor library instance loaded in a process. When entrypoint rewriting is implemented, this will be used by libglvnd to determine whether a given entrypoint implementation is compatible with a given context, by comparing the vendor owning the context with the vendor owning the implementation. This changes the function prototype of __glDispatchMakeCurrent() to include the vendorID as an argument, which will be saved off in the API state, and return a boolean value to indicate whether make current succeeded.
2014-01-24 04:51:49 +01:00
vendor->vendorID = vendorID;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
if (!vendor->name) {
goto fail;
}
vendor->dlhandle = dlhandle;
vendor->staticDispatch = dispatch;
[GLX] Add libglxgldispatch.[ch] This implements thin wrappers around libGLdispatch which allow vendors to manage their own dispatch tables. See documentation in the interface header file libglxabi.h for more details.
2013-08-12 22:12:09 +02:00
vendor->glDispatch = (__GLdispatchTable *)
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
__glDispatchCreateTable(
dispatch->glxvc.getProcAddress
);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
if (!vendor->glDispatch) {
goto fail;
}
[GLX] Implement __glXFetchDispatchEntry() This function is an implementation of the fetchDispatchEntry export, which is called by vendor-implemented GLX dipsatchers to fetch a dispatch table entry given a logical dispatch table index. This change also implements the logic for assigning dispatch table indices to GLX entrypoints at glXGetProcAddress() time. The dynamic dispatch table is actually a hashtable which uses the "index" as a key, and not a flat array, to prevent wasted memory usage from sparse dispatch tables. Since GLX entrypoints are generally not performance-critical this should be fine.
2013-08-12 22:12:09 +02:00
dynDispatch = vendor->dynDispatch
= malloc(sizeof(__GLXdispatchTableDynamic));
if (!dynDispatch) {
goto fail;
}
/* Initialize the dynamic dispatch table */
LKDHASH_INIT(__glXPthreadFuncs, dynDispatch->hash);
dynDispatch->vendor = vendor;
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
[libglx] Fix usage of incorrect hash key when adding to __glXVendorNameHash
2014-01-24 05:10:55 +01:00
HASH_ADD_KEYPTR(hh, _LH(__glXVendorNameHash), vendor->name,
strlen(vendor->name), pEntry);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
} else {
/* Some other thread added a vendor */
vendor = pEntry->vendor;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorNameHash);
}
return vendor;
fail:
if (locked) {
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorNameHash);
}
if (dlhandle) {
dlclose(dlhandle);
}
if (vendor) {
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
TeardownVendor(vendor, False/* doLibraryUnload */);
[GLX] Implement loading vendor libraries This implements __glXLookupVendorByName(), which is responsible for checking a hash table for existing loaded vendors with the given name, and loading the vendor with that name if no existing vendors are found. This also implements __glXGetGLXDispatchAddress(), which iterates through this hash table checking whether each loaded vendor supports dispatching to the given GLX entrypoint.
2013-08-12 22:12:09 +02:00
}
free(pEntry);
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
return NULL;
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
static void CleanupVendorNameEntry(void *unused,
__GLXvendorNameHash *pEntry)
{
TeardownVendor(pEntry->vendor, True/* doLibraryUnload */);
}
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXvendorInfo *__glXLookupVendorByScreen(Display *dpy, const int screen)
{
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
__GLXvendorInfo *vendor = NULL;
__GLXvendorScreenHash *pEntry = NULL;
__GLXvendorScreenHashKey key;
if (screen < 0) {
return NULL;
}
memset(&key, 0, sizeof(key));
key.dpy = dpy;
key.screen = screen;
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXVendorScreenHash);
HASH_FIND(hh, _LH(__glXVendorScreenHash), &key,
sizeof(key), pEntry);
if (pEntry) {
vendor = pEntry->vendor;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorScreenHash);
if (!pEntry) {
/*
* If we have specified a vendor library, use that. Otherwise,
* try to lookup the vendor based on the current screen.
*/
const char *preloadedVendorName = getenv("__GLX_VENDOR_LIBRARY_NAME");
char *queriedVendorName;
assert(!vendor);
if (preloadedVendorName) {
vendor = __glXLookupVendorByName(preloadedVendorName);
}
Return NULL in __glXLookupVendorByScreen() if dpy == NULL Instead of crashing with an assertion, simply return NULL if __glXLookupVendorByScreen() failed to find a vendor. Callers should be able to handle this error gracefully. The GetProcAddress unit test relies on having a NULL display. To avoid breaking this test, only check for a NULL display after first attempting to look up a preloaded vendor name. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-18 22:54:01 +01:00
if (!vendor && (dpy != NULL)) {
Add x11glvnd X11 extension This will be used to handle the corner case when a drawable XID is passed into the API library which belongs to an X window or otherwise has never been seen before by the process, by providing a way to lookup which screen the corresponding drawable belongs. This still is racey since we can't guarantee a different process won't free the XID and cause it to be recycled as a handle for a different resource after the lookup, but better than not being able to figure out the mapping at all. This extension also solves the less-difficult problem of mapping a screen to a vendor name (though it may make more sense to at some point directly map drawables to a vendor to better support render-offload scenarios).
2013-08-12 22:12:09 +02:00
queriedVendorName = XGLVQueryScreenVendorMapping(dpy, screen);
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
vendor = __glXLookupVendorByName(queriedVendorName);
Xfree(queriedVendorName);
}
if (!vendor) {
Return NULL in __glXLookupVendorByScreen() if dpy == NULL Instead of crashing with an assertion, simply return NULL if __glXLookupVendorByScreen() failed to find a vendor. Callers should be able to handle this error gracefully. The GetProcAddress unit test relies on having a NULL display. To avoid breaking this test, only check for a NULL display after first attempting to look up a preloaded vendor name. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-18 22:54:01 +01:00
/* No vendor available */
return NULL;
[GLX] Implement __glXLookupVendorByScreen() This function, which looks up a vendor given a screen number, is used by several helper functions which look up core GL and GLX dispatch tables given a screen number, and directly by the API library's make curent proc. This relies on the (still unimplemented) function __glXLookupVendorByName().
2013-08-12 22:12:09 +02:00
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXVendorScreenHash);
HASH_FIND(hh, _LH(__glXVendorScreenHash), &key, sizeof(key), pEntry);
if (!pEntry) {
pEntry = malloc(sizeof(*pEntry));
if (!pEntry) {
return NULL;
}
pEntry->key.dpy = dpy;
pEntry->key.screen = screen;
pEntry->vendor = vendor;
HASH_ADD(hh, _LH(__glXVendorScreenHash), key,
sizeof(__GLXvendorScreenHashKey), pEntry);
} else {
/* Some other thread already added a vendor */
vendor = pEntry->vendor;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXVendorScreenHash);
}
DBG_PRINTF(10, "Found vendor \"%s\" for screen %d\n",
vendor->name, screen);
return vendor;
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
const __GLXdispatchTableStatic *__glXGetStaticDispatch(Display *dpy, const int screen)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXvendorInfo *vendor = __glXLookupVendorByScreen(dpy, screen);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
if (vendor) {
assert(vendor->staticDispatch);
return vendor->staticDispatch;
} else {
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
return __glXDispatchNoopPtr;
}
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
const __GLXdispatchTableStatic * __glXGetDrawableStaticDispatch(Display *dpy,
GLXDrawable drawable)
{
int screen = __glXScreenFromDrawable(dpy, drawable);
return __glXGetStaticDispatch(dpy, screen);
}
[GLX] Define GLdispatch API Add a new header file, GLdispatch.h, which defines an API for window-system libraries such as libGLX to manage core GL dispatch tables as well as TLS. Refactor the __GLXAPIState to be derived from __GLdispatchAPIState, make __GLXvendorInfo::glDispatch type __GLdispatchTable, and implement make current/get current functionality using this API. At some point this API will be implemented in a shared library used by both libGLX and libEGL.
2013-08-12 22:12:09 +02:00
__GLdispatchTable *__glXGetGLDispatch(Display *dpy, const int screen)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXvendorInfo *vendor = __glXLookupVendorByScreen(dpy, screen);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
if (vendor) {
assert(vendor->glDispatch);
return vendor->glDispatch;
} else {
return NULL;
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
__GLXvendorInfo *__glXGetDynDispatch(Display *dpy, const int screen)
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
{
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
__glXThreadInitialize();
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
__GLXvendorInfo *vendor = __glXLookupVendorByScreen(dpy, screen);
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
return vendor;
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
Change glXGetClientString strings to be per-display. Add a hashtable for keeping track of per-display data and move the client strings into that table.
2015-04-14 19:58:43 +02:00
__GLXdisplayInfo *__glXLookupDisplay(Display *dpy)
{
__GLXdisplayInfoHash *pEntry = NULL;
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
if (dpy == NULL) {
return NULL;
}
Change glXGetClientString strings to be per-display. Add a hashtable for keeping track of per-display data and move the client strings into that table.
2015-04-14 19:58:43 +02:00
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, pEntry);
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
if (pEntry != NULL) {
return &pEntry->info;
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, pEntry);
if (pEntry == NULL) {
pEntry = (__GLXdisplayInfoHash *) malloc(sizeof(*pEntry));
if (pEntry != NULL) {
memset(pEntry, 0, sizeof(*pEntry));
pEntry->dpy = dpy;
HASH_ADD_PTR(_LH(__glXDisplayInfoHash), dpy, pEntry);
}
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
if (pEntry != NULL) {
return &pEntry->info;
} else {
return NULL;
}
}
void __glXFreeDisplay(Display *dpy)
{
__GLXdisplayInfoHash *pEntry = NULL;
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, pEntry);
if (pEntry != NULL) {
HASH_DEL(_LH(__glXDisplayInfoHash), pEntry);
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDisplayInfoHash);
if (pEntry != NULL) {
int i;
for (i=0; i<GLX_CLIENT_STRING_LAST_ATTRIB; i++) {
if (pEntry->info.clientStrings[i] != NULL) {
free(pEntry->info.clientStrings[i]);
}
}
free(pEntry);
}
}
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
/****************************************************************************/
/*
* __glXScreenPointerMappingHash is a hash table that maps a void*
* (either GLXContext or GLXFBConfig) to a screen index. Note this
* stores both GLXContext and GLXFBConfig in this table.
*/
typedef struct {
void *ptr;
int screen;
UT_hash_handle hh;
} __GLXscreenPointerMappingHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXscreenPointerMappingHash, __glXScreenPointerMappingHash);
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
static void AddScreenPointerMapping(void *ptr, int screen)
{
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenPointerMappingHash *pEntry;
if (ptr == NULL) {
return;
}
if (screen < 0) {
return;
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
HASH_FIND_PTR(_LH(__glXScreenPointerMappingHash), &ptr, pEntry);
if (pEntry == NULL) {
pEntry = malloc(sizeof(*pEntry));
pEntry->ptr = ptr;
pEntry->screen = screen;
HASH_ADD_PTR(_LH(__glXScreenPointerMappingHash), ptr, pEntry);
} else {
pEntry->screen = screen;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
static void RemoveScreenPointerMapping(void *ptr)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenPointerMappingHash *pEntry;
if (ptr == NULL) {
return;
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
Fix use of HASH_FIND() in RemoveScreenPointerMapping() Replace HASH_FIND() with the convenience macro HASH_FIND_PTR() in RemoveScreenPointerMapping() and ScreenFromPointer(), to be consistent with AddScreenPointerMapping(). This has the side-effect of fixing invalid usage of the original HASH_FIND() macro in RemoveScreenPointerMapping(). Signed-Off-By: Brian Nguyen <brnguyen@nvidia.com>
2013-09-27 02:27:09 +02:00
HASH_FIND_PTR(_LH(__glXScreenPointerMappingHash), &ptr, pEntry);
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
if (pEntry != NULL) {
HASH_DELETE(hh, _LH(__glXScreenPointerMappingHash), pEntry);
free(pEntry);
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
static int ScreenFromPointer(void *ptr)
{
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenPointerMappingHash *pEntry;
int screen = -1;
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
Fix use of HASH_FIND() in RemoveScreenPointerMapping() Replace HASH_FIND() with the convenience macro HASH_FIND_PTR() in RemoveScreenPointerMapping() and ScreenFromPointer(), to be consistent with AddScreenPointerMapping(). This has the side-effect of fixing invalid usage of the original HASH_FIND() macro in RemoveScreenPointerMapping(). Signed-Off-By: Brian Nguyen <brnguyen@nvidia.com>
2013-09-27 02:27:09 +02:00
HASH_FIND_PTR(_LH(__glXScreenPointerMappingHash), &ptr, pEntry);
[GLX] Implement screen-pointer mapping helper functions
2013-08-12 22:12:09 +02:00
if (pEntry != NULL) {
screen = pEntry->screen;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenPointerMappingHash);
return screen;
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
/**
* Common function for the various __glXVendorFrom* functions.
*/
static int CommonVendorFromScreen(Display *dpy, int screen, int *retScreen, __GLXvendorInfo **retVendor)
{
if (retScreen != NULL) {
*retScreen = screen;
}
if (retVendor != NULL) {
if (screen >= 0) {
*retVendor = __glXLookupVendorByScreen(dpy, screen);
} else {
*retVendor = NULL;
}
}
return (screen >= 0 ? 0 : -1);
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXAddScreenContextMapping(Display *dpy, GLXContext context, int screen, __GLXvendorInfo *vendor)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
AddScreenPointerMapping(context, screen);
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXRemoveScreenContextMapping(Display *dpy, GLXContext context)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
RemoveScreenPointerMapping(context);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
int __glXScreenFromContext(GLXContext context)
{
return ScreenFromPointer(context);
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
int __glXVendorFromContext(Display *dpy, GLXContext context, int *retScreen, __GLXvendorInfo **retVendor)
{
int screen = ScreenFromPointer(context);
return CommonVendorFromScreen(dpy, screen, retScreen, retVendor);
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXAddScreenFBConfigMapping(Display *dpy, GLXFBConfig config, int screen, __GLXvendorInfo *vendor)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
AddScreenPointerMapping(config, screen);
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXRemoveScreenFBConfigMapping(Display *dpy, GLXFBConfig config)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
RemoveScreenPointerMapping(config);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
int __glXScreenFromFBConfig(GLXFBConfig config)
{
return ScreenFromPointer(config);
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
int __glXVendorFromFBConfig(Display *dpy, GLXFBConfig config, int *retScreen, __GLXvendorInfo **retVendor)
{
int screen = ScreenFromPointer(config);
return CommonVendorFromScreen(dpy, screen, retScreen, retVendor);
}
libGLX: Add visual to vendor mappings. Add functions to __GLXapiExports to manage mappings from an XVisualInfo to a vendor. This should allow the same sort of arbitrary vendor selection for the GLX 1.2 XVisualInfo-based functions as for the GLXFBConfig-based ones.
2015-04-20 22:29:07 +02:00
// Internally, we use the screen number to look up a vendor, so we don't need
// to record anything else for an XVisualInfo.
void __glXAddScreenVisualMapping(Display *dpy, const XVisualInfo *visual, __GLXvendorInfo *vendor)
{
}
void __glXRemoveScreenVisualMapping(Display *dpy, const XVisualInfo *visual)
{
}
int __glXVendorFromVisual(Display *dpy, const XVisualInfo *visual, __GLXvendorInfo **retVendor)
{
if (retVendor != NULL) {
*retVendor = __glXLookupVendorByScreen(dpy, visual->screen);
}
return 0;
}
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
/****************************************************************************/
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
/*
* __glXScreenXIDMappingHash is a hash table which maps XIDs to screens.
*/
typedef struct {
XID xid;
int screen;
UT_hash_handle hh;
} __GLXscreenXIDMappingHash;
static DEFINE_INITIALIZED_LKDHASH(__GLXscreenXIDMappingHash, __glXScreenXIDMappingHash);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
static void AddScreenXIDMapping(XID xid, int screen)
{
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenXIDMappingHash *pEntry = NULL;
if (xid == None) {
return;
}
if (screen < 0) {
return;
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
HASH_FIND(hh, _LH(__glXScreenXIDMappingHash), &xid, sizeof(xid), pEntry);
if (pEntry == NULL) {
pEntry = malloc(sizeof(*pEntry));
pEntry->xid = xid;
pEntry->screen = screen;
HASH_ADD(hh, _LH(__glXScreenXIDMappingHash), xid, sizeof(xid), pEntry);
} else {
pEntry->screen = screen;
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
static void RemoveScreenXIDMapping(XID xid)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenXIDMappingHash *pEntry;
if (xid == None) {
return;
}
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
HASH_FIND(hh, _LH(__glXScreenXIDMappingHash), &xid, sizeof(xid), pEntry);
if (pEntry != NULL) {
HASH_DELETE(hh, _LH(__glXScreenXIDMappingHash), pEntry);
free(pEntry);
}
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
static int ScreenFromXID(Display *dpy, XID xid)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
__GLXscreenXIDMappingHash *pEntry;
int screen = -1;
LKDHASH_RDLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
HASH_FIND(hh, _LH(__glXScreenXIDMappingHash), &xid, sizeof(xid), pEntry);
if (pEntry) {
screen = pEntry->screen;
Unlock the XID screen hash prior to calling AddScreenXIDMapping() from ScreenFromXID() Failing to do this results in deadlock since AddScreenXIDMapping() attempts to acquire the XID screen hash write lock. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-18 23:47:42 +01:00
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
} else {
Add x11glvnd X11 extension This will be used to handle the corner case when a drawable XID is passed into the API library which belongs to an X window or otherwise has never been seen before by the process, by providing a way to lookup which screen the corresponding drawable belongs. This still is racey since we can't guarantee a different process won't free the XID and cause it to be recycled as a handle for a different resource after the lookup, but better than not being able to figure out the mapping at all. This extension also solves the less-difficult problem of mapping a screen to a vendor name (though it may make more sense to at some point directly map drawables to a vendor to better support render-offload scenarios).
2013-08-12 22:12:09 +02:00
screen = XGLVQueryXIDScreenMapping(dpy, xid);
Unlock the XID screen hash prior to calling AddScreenXIDMapping() from ScreenFromXID() Failing to do this results in deadlock since AddScreenXIDMapping() attempts to acquire the XID screen hash write lock. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-18 23:47:42 +01:00
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXScreenXIDMappingHash);
[GLX] Implement screen-XID mapping helper functions
2013-08-12 22:12:09 +02:00
AddScreenXIDMapping(xid, screen);
}
return screen;
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXAddScreenDrawableMapping(Display *dpy, GLXDrawable drawable, int screen, __GLXvendorInfo *vendor)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
AddScreenXIDMapping(drawable, screen);
}
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
void __glXRemoveScreenDrawableMapping(Display *dpy, GLXDrawable drawable)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
Simplify vendor-library ABI for libglx - Pull GL dispatch callback typedefs into GLdispatchABI.h. This is a common header which will be shared between the libGLX and libEGL ABIs. - Add extern "C" blocks to libglxabi.h and GLdispatchABI.h so these headers may be used with vendor libraries that are built C++. - Remove support for auxiliary dispatch table management (libglxgldispatch.[ch] and __GLdispatchExports). This can be added back in later on if it proves useful. - In libglxmappings.c, replace static initialization of glxExportsTable with one-time runtime initialization of the table. - In libglxmappings.c, use __glDispatchCreateTable() directly to create the initial dispatch table. - In libglxnoopdefs.h, remove unnecessary includes of libglxabipriv.h and libglxnoop.h. - Add screen mapping functions to the GLX exports table. Some extension functions not implemented by libglvnd, e.g. glXCreateContextAttribsARB() from GLX_ARB_create_context, may need to update the mappings from context or drawable to screen that are managed by libglvnd in order to work properly. Additionally, dispatch functions implemented by vendor libraries for GLX extension functions may want to query these mappings in order to properly dispatch the call. - Remove the getDispatchProto() vendor callback. This is not needed by libglvnd since libglvnd does not support mapping more than one entrypoint to a single dispatch stub. See GLdispatch.c for the rationale behind this decision. - Remove redundant typedefs to prevent build errors. - Delete the vendorData parameter from the getProcAddress() vendor callback, which isn't useful if there is no support for more than one libglvnd dispatch table per context. Add the isClientAPI parameter, which can be used to distinguish between getProcAddress() requests for GLX functions versus getProcAddress() requests for client API functions. - Remove the "screen" argument from Remove.*Mapping() functions. This is unnecessary, as the hash key used to lookup the mapping object in libglvnd's hashtables doesn't depend on the screen (which is the hash value). It's problematic since in some cases we don't actually know the value of the screen mapped to by a key. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2013-11-26 00:21:41 +01:00
RemoveScreenXIDMapping(drawable);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
int __glXScreenFromDrawable(Display *dpy, GLXDrawable drawable)
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
{
[GLX] Include libglxmapping.c and libglxnoop.h in build libglxmapping.c implements functions needed for libGLX to map function calls to vendors for dispatching. libglxnoop.h contains a pointer to a no-op dispatch table. These will be re-implemented in a later change.
2013-08-23 01:21:31 +02:00
return ScreenFromXID(dpy, drawable);
Add initial libGLX implementation
2013-08-23 01:06:53 +02:00
}
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
libGLX: Rework the ABI for object-to-vendor mappings. Change the functions in __GLXapiExports to map from objects (drawables, contexts, FBConfigs) to (screen, vendor) pairs. Internally, libGLX still uses an (object -> screen -> vendor) mapping, but now that's an implementation detail.
2015-04-19 18:30:21 +02:00
int __glXVendorFromDrawable(Display *dpy, GLXDrawable drawable, int *retScreen, __GLXvendorInfo **retVendor)
{
int screen = ScreenFromXID(dpy, drawable);
return CommonVendorFromScreen(dpy, screen, retScreen, retVendor);
}
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
/*!
* This handles freeing all mapping state during library teardown
[libglxmapping] Don't clear out mapping hashtables on a fork Mappings defined in the parent should remain valid in the child process, so don't clear out mappings after a fork since they may be needed for GLX calls made in the child. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-29 22:20:13 +01:00
* or resetting locks on fork recovery.
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
*/
void __glXMappingTeardown(Bool doReset)
{
if (doReset) {
/*
* If we're just doing fork recovery, we don't actually want to unload
[libglxmapping] Don't clear out mapping hashtables on a fork Mappings defined in the parent should remain valid in the child process, so don't clear out mappings after a fork since they may be needed for GLX calls made in the child. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-29 22:20:13 +01:00
* any currently loaded vendors _or_ remove any mappings (they should
* still be valid in the new process, and may be needed if the child
* tries using pointers/XIDs that were created in the parent). Just
* reset the corresponding locks.
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
*/
[libglxmapping] Don't clear out mapping hashtables on a fork Mappings defined in the parent should remain valid in the child process, so don't clear out mappings after a fork since they may be needed for GLX calls made in the child. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-29 22:20:13 +01:00
__glXPthreadFuncs.rwlock_init(&__glXDispatchIndexHash.lock, NULL);
__glXPthreadFuncs.rwlock_init(&__glXVendorScreenHash.lock, NULL);
__glXPthreadFuncs.rwlock_init(&__glXScreenPointerMappingHash.lock, NULL);
__glXPthreadFuncs.rwlock_init(&__glXScreenXIDMappingHash.lock, NULL);
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
__glXPthreadFuncs.rwlock_init(&__glXVendorNameHash.lock, NULL);
Change glXGetClientString strings to be per-display. Add a hashtable for keeping track of per-display data and move the client strings into that table.
2015-04-14 19:58:43 +02:00
__glXPthreadFuncs.rwlock_init(&__glXDisplayInfoHash.lock, NULL);
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
} else {
[libglxmapping] Don't clear out mapping hashtables on a fork Mappings defined in the parent should remain valid in the child process, so don't clear out mappings after a fork since they may be needed for GLX calls made in the child. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-29 22:20:13 +01:00
/* Tear down all hashtables used in this file */
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXdispatchIndexHash,
__glXDispatchIndexHash, CleanupDispatchIndexEntry,
NULL, False);
LKDHASH_WRLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
__glXNextUnusedHashIndex = 0;
LKDHASH_UNLOCK(__glXPthreadFuncs, __glXDispatchIndexHash);
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXvendorScreenHash,
__glXVendorScreenHash, NULL, NULL, False);
Change glXGetClientString strings to be per-display. Add a hashtable for keeping track of per-display data and move the client strings into that table.
2015-04-14 19:58:43 +02:00
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXdisplayInfoHash,
__glXDisplayInfoHash, NULL, NULL, False);
[libglxmapping] Don't clear out mapping hashtables on a fork Mappings defined in the parent should remain valid in the child process, so don't clear out mappings after a fork since they may be needed for GLX calls made in the child. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-29 22:20:13 +01:00
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXscreenPointerMappingHash,
__glXScreenPointerMappingHash, NULL, NULL, False);
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXscreenXIDMappingHash,
__glXScreenXIDMappingHash, NULL, NULL, False);
Implement fork-handling and library teardown paths - Define a function __glXThreadInitialize() which gets called when entering any GLX entrypoint, or when __glXGetDynDispatch() is called by a vendor-provided GLX extension entrypoint. This function detects if a fork occurred since the last entrypoint was called, and performs fork recovery if needed. - Implement __glXFini() so that libGLX cleans up allocated resources when it is unloaded. These paths make heavy use of the LKDHASH_TEARDOWN() macro that was implemented in a previous commit. Signed-off-by: Brian Nguyen <brnguyen@nvidia.com>
2014-10-03 01:17:59 +02:00
/*
* This implicitly unloads vendor libraries that were loaded when
* they were added to this hashtable.
*/
LKDHASH_TEARDOWN(__glXPthreadFuncs, __GLXvendorNameHash,
__glXVendorNameHash, CleanupVendorNameEntry,
NULL, False);
}
}
Reference in a new issue Copy permalink