GitLab

This patch avoid to call exit() in uthash for better error handling

Fix https://github.com/NVIDIA/libglvnd/issues/106
Patch suggested by https://github.com/tbeu

Signed-off-by: Nicolas Chauvet <kwizart@gmail.com>

Change the assembly template arrays for ARMv7 to use arrays of 16-bit integers
instead of 8-bit.

This removes the need to byte swap them on little-endian systems.

Add a new unit test, testpatchentrypoints_gldispatch. It calls into
libGLdispatch directly instead of going through GLX or EGL, and it tests
patching and unpatching between multiple vendor libraries.

Rewrote the x86-64 assembly for the entrypoint patching tests. It now uses
absolute memory addresses instead of RIP-relative, so it can work even if the
variable that it's supposed to update isn't within +-2GB of the function.

Moved the code for testing entrypoint patching into a helper library so that
it can be used for more than just GLX.

Rename the GLX_dummy directory to just "dummy", since the code in it will be
used for non-GLX tests.

Added a separate script glxenv.sh for the common environment variables used by
the other GLX tests.

Removed the testx11glvndproto and testglxnscreens tests, since both of them
depend on the x11glvnd X extension, which is no longer used.

Removed the unused GLX_dummy_copy stuff from the GLX_dummy makefile. Also
removed the COMMON_* variables, since they're only ever used once each.

Moved the UnionExtensionStrings and IntersectionExtensionStrings functions from
EGL to utils_misc.c.

Changed libGLX to use the common UnionExtensionStrings and IsTokenInString
functions instead of its own versions of them.

Moved ParseClientVersionString to libglx.c near where it's used, and deleted
libglxstring.c and libglxstring.h.

In __eglGetEGLDispatchAddress, initialize the addr variable to NULL. Otherwise,
it could end up being uninitialized if there are no vendor libraries loaded.

Fixes https://github.com/NVIDIA/libglvnd/issues/96

Increment the minor version number so that other packages can check if the EGL
interface is available.

Add an interface for EGL.

In egldispatchstubs.c, __eglDispatchFetchByDevice will report an
EGL_BAD_DEVICE_EXT error for an invalid device instead of EGL_BAD_DISPLAY.

In LoadVendorsFromConfigDir, fix a typo in the path separator handling.

Changed the default vendor config paths to be based on the directory options
for configure. libEGL will now look under the sysconfigdir and datadir paths,
in a "glvnd/egl_vendor.d" subdirectory.

Added the "datadir" variable to the pkg-config file, so that other packages can
find the expected location of the JSON files.

Add the flag -Wno-misleading-indentation to the cJSON source file, to avoid a
compiler warning (and resulting error) on more recent versions of GCC.

Trying to cast between __eglMustCastToProperFunctionPointerType and other
function pointer types causes strict aliasing warnings on some compilers.

Instead, just use a simple (void *) type for retrieving function pointers from
a vendor library, like libGLX does.

Fix the message types in the _eglReportError and _eglReportCritical macros.

In eglDebugMessageControlKHR, check if the attribute list is valid even if the
callback is NULL.

In eglDebugMessageControlKHR, set the callback pointer whether or not the
attribute list is NULL.

In eglLabelObjectKHR, if the vendor library returns an error for an object type
other than EGL_OBJECT_THREAD_KHR, then return that error to the caller.

Fix the error handling and return value in eglBindAPI if the API isn't one of
GL or GLES.

Add a missing error callback in eglMakeCurrent.

In glXMakeCurrent, make sure to add the new display to libGLX's tracking, so
that it gets a callback if the display is closed.

This fixes a dangling pointer to the display in the __GLXThreadState struct if
the application closes the display while it's still current.

Change the package version to 0.1.999 to distinguish the master branch from
any release versions.

Release versions will get their own branches and tags with a specific version
number.

This is likely a temporary arrangement. For the near future, any releases will
likely be taken from specific commits in master that have gotten adequate
testing. This provides an easy way to tag those releases.

Using a large revision number for master ensures that other autoconf (or at
least pkg-config based) builds that expect a minimum version number will also
work with the latest master branch.

Reduce the dispatch stubs in EGL to only include core functions and client
extensions. Any other functions should be provided by the vendor libraries.

libEGL will now parse the file_format_version value in each vendor's JSON file.

libEGL will now check the client extension strings of each vendor when the
vendor is loaded, and record whether a vendor supports
EGL_EXT_device_base/EGL_EXT_device_enumeration, and the device, Wayland, and
X11 platform extensions.

eglGetDisplay will now check for whether any vendor supports Wayland before it
tries to guess whether the native display pointer is a Wayland display.

When enumerating the device handles for each vendor, libEGL will check for
either EGL_EXT_device_base or EGL_EXT_device_enumeration, instead of just
EGL_EXT_device_base.

eglGetDisplay will now check for EGL_PLATFORM_DEVICE_EXT and
EGL_PLATFORM_WAYLAND_KHR.

For EGL_PLATFORM_DEVICE_EXT, it will just check if the native display is a
valid EGLDeviceEXT handle.

For EGL_PLATFORM_WAYLAND_KHR, it will check the actual pointer, using similar
logic to Mesa.

Check if the __EGLdeviceInfo pointer is actually valid before trying to
dereference it.

libEGL will now forward calls to eglBindAPI to the vendor libraries.

Defined as part of the interface that libEGL only supports OpenGL and GLES.

This should simplify the task of porting a driver to EGL, since the eglBindAPI
behavior is closer to a non-glvnd driver.

In __glXAPITeardown, use pthread_mutex_trylock to take the context hash mutex,
and just skip freeing the context data if the mutex isn't available.

In some cases, such as a multi-threaded program that hits an X11 I/O error,
another thread could be blocked in a glXMakeCurrent call, and so trying to take
the context list mutex would deadlock.

In addition, fix the current context bookkeeping in fork recovery. After a
fork, the contexts should still exist, but none of them will be current
anymore.

Add pointers for pthread_mutex_trylock, pthread_rwlock_tryrdlock, and
pthread_rwlock_trywrlock to the GLVNDPthreadFuncs table.

In __glDispatchFini, remove the assert that the current context list is empty.
Even though libGLX/libEGL will clear out the current context for the current
thread, another thread may still have a current context.

Implemented the EGL_KHR_debug extension in libEGL.

Updated the error reporting throughout libEGL to call the debug callback.

This requires that all vendor libraries also support EGL_KHR_debug. The reason
is that the debug callback has to be called every time an EGL error is
generated, and vendor libraries are still responsible for keeping track of EGL
errors on their own.

libEGL should be able to cope with a vendor library that doens't support
EGL_KHR_debug, but if that vendor library is used, then the extension won't
work correctly.

The implementation is mostly based off of libGLX.

Unlike GLX, libEGL will load all vendor libraries up front. This is necessary
for dealing with eglGetPlatformDisplay, as well as many client extensions.

Dispatching EGL functions is generally simpler than GLX. All display extension
functions by definition can be dispatched based on an EGLDisplay handle, so
it doesn't need to provide lookup functions for contexts or surfaces, and
vendor libraries don't have to add any EGL objects to tracking.

Only OpenGL and OpenGL ES and a handful of client extensions are supported so
far.

This will be used to parse JSON config files that will describe the available
vendor libraries for EGL.

In testpatchentrypoints, remove the additional calls to glVertex3fv after
releasing the current context.

libGLdispatch doesn't unpatch entrypoints from __glDispatchLoseCurrent anymore,
so those calls will still increment the __glXSawVertex3fv counter.

This means that it no longer tests entrypoint unpatching, but fixing that would
require multiple vendor libraries, which with GLX requires multiple screens.

Update the README file to reflect various changes to libglvnd.

In __glDispatchLoseCurrent, don't try to restore the default entrypoints.
Instead, __glDispatchMakeCurrent will check if it's using a different vendor
library, and if so, it will unpatch and repatch the entrypoints then. If it's
using the same vendor library (which will usually be the case), then it can
leave them patched and skip the patch overhead.

Some applications will call glXMakeCurrent to release and bind the same context
every frame, sometimes multiples times. Each patch and unpatch sequnce can chew
up 1-2 milliseconds. That's enough to significantly reduce the framerate of
some applications.
Reviewed-by: James Jones <jajones@nvidia.com>

Moved the unlock in __glXLookupVendorByName to after the calls to update the
GLX entrypoints.

Fixed a typo in GLXEntrypointUpdateCallback.

Remove the libGLX_patchentry dummy vendor library. The libGLX_dummy.so library
will provide the entrypoint patching callbacks based on an environment
variable.

The testglxmakecurrent tests will now test both the GLXFBConfig and
XVisualInfo-based GLX functions.

The tests will also now cover using glXCreateContextAttribsARB to create a
rendering context.

Added an implementation and dispatch function for glXCreateContextAttribsARB.