+/**************************************************************************
+ *
+ * Copyright 2008 VMware, Inc.
+ * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
+ * Copyright 2010-2011 LunarG, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
/**
* Functions related to EGLDisplay.
*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>
+#include "c11/threads.h"
+#include "util/u_atomic.h"
+
#include "eglcontext.h"
+#include "eglcurrent.h"
#include "eglsurface.h"
#include "egldisplay.h"
#include "egldriver.h"
#include "eglglobals.h"
-#include "eglstring.h"
-#include "eglmutex.h"
#include "egllog.h"
+#include "eglimage.h"
+#include "eglsync.h"
+
+/* Includes for _eglNativePlatformDetectNativeDisplay */
+#ifdef HAVE_MINCORE
+#include <unistd.h>
+#include <sys/mman.h>
+#endif
+#ifdef HAVE_WAYLAND_PLATFORM
+#include <wayland-client.h>
+#endif
+#ifdef HAVE_DRM_PLATFORM
+#include <gbm.h>
+#endif
/**
- * Finish display management.
+ * Map --with-platforms names to platform types.
*/
-void
-_eglFiniDisplay(void)
-{
- _EGLDisplay *dpyList, *dpy;
+static const struct {
+ _EGLPlatformType platform;
+ const char *name;
+} egl_platforms[_EGL_NUM_PLATFORMS] = {
+ { _EGL_PLATFORM_X11, "x11" },
+ { _EGL_PLATFORM_WAYLAND, "wayland" },
+ { _EGL_PLATFORM_DRM, "drm" },
+ { _EGL_PLATFORM_ANDROID, "android" },
+ { _EGL_PLATFORM_HAIKU, "haiku" },
+ { _EGL_PLATFORM_SURFACELESS, "surfaceless" },
+};
- /* atexit function is called with global mutex locked */
- dpyList = _eglGlobal.DisplayList;
- while (dpyList) {
- /* pop list head */
- dpy = dpyList;
- dpyList = dpyList->Next;
- if (dpy->ContextList || dpy->SurfaceList)
- _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
+/**
+ * Return the native platform by parsing EGL_PLATFORM.
+ */
+static _EGLPlatformType
+_eglGetNativePlatformFromEnv(void)
+{
+ _EGLPlatformType plat = _EGL_INVALID_PLATFORM;
+ const char *plat_name;
+ EGLint i;
+
+ plat_name = getenv("EGL_PLATFORM");
+ /* try deprecated env variable */
+ if (!plat_name || !plat_name[0])
+ plat_name = getenv("EGL_DISPLAY");
+ if (!plat_name || !plat_name[0])
+ return _EGL_INVALID_PLATFORM;
- free(dpy);
+ for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
+ if (strcmp(egl_platforms[i].name, plat_name) == 0) {
+ plat = egl_platforms[i].platform;
+ break;
+ }
}
- _eglGlobal.DisplayList = NULL;
+
+ return plat;
}
/**
- * If the first character is '!' we interpret it as specific driver name
- * (i.e. "!r200" or "!i830"). Whatever follows ':' is interpreted as
- * arguments.
- *
- * The caller may free() the returned driver name.
+ * Perform validity checks on a generic pointer.
*/
-char *
-_eglSplitDisplayString(const char *dpyString, const char **args)
+static EGLBoolean
+_eglPointerIsDereferencable(void *p)
{
- char *drv, *p;
+#ifdef HAVE_MINCORE
+ uintptr_t addr = (uintptr_t) p;
+ unsigned char valid = 0;
+ const long page_size = getpagesize();
- if (!dpyString || dpyString[0] != '!')
- return NULL;
- drv = _eglstrdup(dpyString + 1);
- if (!drv)
- return NULL;
+ if (p == NULL)
+ return EGL_FALSE;
- p = strchr(dpyString, ':');
- if (p) {
- drv[p - dpyString] = '\0';
- p++;
+ /* align addr to page_size */
+ addr &= ~(page_size - 1);
+
+ if (mincore((void *) addr, page_size, &valid) < 0) {
+ _eglLog(_EGL_DEBUG, "mincore failed: %m");
+ return EGL_FALSE;
}
- if (args)
- *args = p;
- return drv;
+ return (valid & 0x01) == 0x01;
+#else
+ return p != NULL;
+#endif
}
/**
- * Allocate a new _EGLDisplay object for the given nativeDisplay handle.
- * We'll also try to determine the device driver name at this time.
- *
- * Note that nativeDisplay may be an X Display ptr, or a string.
+ * Try detecting native platform with the help of native display characteristcs.
*/
-_EGLDisplay *
-_eglNewDisplay(NativeDisplayType nativeDisplay)
+static _EGLPlatformType
+_eglNativePlatformDetectNativeDisplay(void *nativeDisplay)
{
- _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
- if (dpy) {
- dpy->NativeDisplay = nativeDisplay;
-
- dpy->DriverName = _eglPreloadDriver(dpy);
- if (!dpy->DriverName) {
- free(dpy);
- return NULL;
- }
+ if (nativeDisplay == EGL_DEFAULT_DISPLAY)
+ return _EGL_INVALID_PLATFORM;
+
+ if (_eglPointerIsDereferencable(nativeDisplay)) {
+ void *first_pointer = *(void **) nativeDisplay;
+
+ (void) first_pointer; /* silence unused var warning */
+
+#ifdef HAVE_WAYLAND_PLATFORM
+ /* wl_display is a wl_proxy, which is a wl_object.
+ * wl_object's first element points to the interfacetype. */
+ if (first_pointer == &wl_display_interface)
+ return _EGL_PLATFORM_WAYLAND;
+#endif
+
+#ifdef HAVE_DRM_PLATFORM
+ /* gbm has a pointer to its constructor as first element. */
+ if (first_pointer == gbm_create_device)
+ return _EGL_PLATFORM_DRM;
+#endif
+
+#ifdef HAVE_X11_PLATFORM
+ /* If not matched to any other platform, fallback to x11. */
+ return _EGL_PLATFORM_X11;
+#endif
+
+#ifdef HAVE_HAIKU_PLATFORM
+ return _EGL_PLATFORM_HAIKU;
+#endif
}
- return dpy;
+
+ return _EGL_INVALID_PLATFORM;
}
/**
- * Link a display to itself and return the handle of the link.
- * The handle can be passed to client directly.
+ * Return the native platform. It is the platform of the EGL native types.
*/
-EGLDisplay
-_eglLinkDisplay(_EGLDisplay *dpy)
+_EGLPlatformType
+_eglGetNativePlatform(void *nativeDisplay)
{
- _eglLockMutex(_eglGlobal.Mutex);
+ static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM;
+ _EGLPlatformType detected_platform = native_platform;
- dpy->Next = _eglGlobal.DisplayList;
- _eglGlobal.DisplayList = dpy;
+ if (detected_platform == _EGL_INVALID_PLATFORM) {
+ const char *detection_method;
- _eglUnlockMutex(_eglGlobal.Mutex);
+ detected_platform = _eglGetNativePlatformFromEnv();
+ detection_method = "environment overwrite";
- return (EGLDisplay) dpy;
+ if (detected_platform == _EGL_INVALID_PLATFORM) {
+ detected_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
+ detection_method = "autodetected";
+ }
+
+ if (detected_platform == _EGL_INVALID_PLATFORM) {
+ detected_platform = _EGL_NATIVE_PLATFORM;
+ detection_method = "build-time configuration";
+ }
+
+ _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)",
+ egl_platforms[detected_platform].name, detection_method);
+
+ p_atomic_cmpxchg(&native_platform, _EGL_INVALID_PLATFORM,
+ detected_platform);
+ }
+
+ return native_platform;
}
/**
- * Unlink a linked display from itself.
- * Accessing an unlinked display should generate EGL_BAD_DISPLAY error.
+ * Finish display management.
*/
void
-_eglUnlinkDisplay(_EGLDisplay *dpy)
+_eglFiniDisplay(void)
{
- _EGLDisplay *prev;
+ _EGLDisplay *dpyList, *dpy;
- _eglLockMutex(_eglGlobal.Mutex);
+ /* atexit function is called with global mutex locked */
+ dpyList = _eglGlobal.DisplayList;
+ while (dpyList) {
+ EGLint i;
- prev = _eglGlobal.DisplayList;
- if (prev != dpy) {
- while (prev) {
- if (prev->Next == dpy)
+ /* pop list head */
+ dpy = dpyList;
+ dpyList = dpyList->Next;
+
+ for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
+ if (dpy->ResourceLists[i]) {
+ _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
break;
- prev = prev->Next;
+ }
}
- assert(prev);
- prev->Next = dpy->Next;
- }
- else {
- _eglGlobal.DisplayList = dpy->Next;
- }
- _eglUnlockMutex(_eglGlobal.Mutex);
+ free(dpy);
+ }
+ _eglGlobal.DisplayList = NULL;
}
/**
- * Find the display corresponding to the specified native display id in all
- * linked displays.
+ * Find the display corresponding to the specified native display, or create a
+ * new one.
*/
_EGLDisplay *
-_eglFindDisplay(NativeDisplayType nativeDisplay)
+_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
{
_EGLDisplay *dpy;
- _eglLockMutex(_eglGlobal.Mutex);
+ if (plat == _EGL_INVALID_PLATFORM)
+ return NULL;
+
+ mtx_lock(_eglGlobal.Mutex);
+ /* search the display list first */
dpy = _eglGlobal.DisplayList;
while (dpy) {
- if (dpy->NativeDisplay == nativeDisplay) {
- _eglUnlockMutex(_eglGlobal.Mutex);
- return dpy;
- }
+ if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy)
+ break;
dpy = dpy->Next;
}
- _eglUnlockMutex(_eglGlobal.Mutex);
+ /* create a new display */
+ if (!dpy) {
+ dpy = calloc(1, sizeof(_EGLDisplay));
+ if (dpy) {
+ mtx_init(&dpy->Mutex, mtx_plain);
+ dpy->Platform = plat;
+ dpy->PlatformDisplay = plat_dpy;
+
+ /* add to the display list */
+ dpy->Next = _eglGlobal.DisplayList;
+ _eglGlobal.DisplayList = dpy;
+ }
+ }
+
+ mtx_unlock(_eglGlobal.Mutex);
- return NULL;
+ return dpy;
}
void
_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
{
- _EGLContext *contexts;
- _EGLSurface *surfaces;
+ _EGLResource *list;
- contexts = display->ContextList;
- surfaces = display->SurfaceList;
-
- while (contexts) {
- _EGLContext *ctx = contexts;
- contexts = contexts->Next;
+ list = display->ResourceLists[_EGL_RESOURCE_CONTEXT];
+ while (list) {
+ _EGLContext *ctx = (_EGLContext *) list;
+ list = list->Next;
_eglUnlinkContext(ctx);
drv->API.DestroyContext(drv, display, ctx);
}
- assert(!display->ContextList);
+ assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
- while (surfaces) {
- _EGLSurface *surf = surfaces;
- surfaces = surfaces->Next;
+ list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
+ while (list) {
+ _EGLSurface *surf = (_EGLSurface *) list;
+ list = list->Next;
_eglUnlinkSurface(surf);
drv->API.DestroySurface(drv, display, surf);
}
- assert(!display->SurfaceList);
+ assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
+
+ list = display->ResourceLists[_EGL_RESOURCE_IMAGE];
+ while (list) {
+ _EGLImage *image = (_EGLImage *) list;
+ list = list->Next;
+
+ _eglUnlinkImage(image);
+ drv->API.DestroyImageKHR(drv, display, image);
+ }
+ assert(!display->ResourceLists[_EGL_RESOURCE_IMAGE]);
+
+ list = display->ResourceLists[_EGL_RESOURCE_SYNC];
+ while (list) {
+ _EGLSync *sync = (_EGLSync *) list;
+ list = list->Next;
+
+ _eglUnlinkSync(sync);
+ drv->API.DestroySyncKHR(drv, display, sync);
+ }
+ assert(!display->ResourceLists[_EGL_RESOURCE_SYNC]);
}
void
_eglCleanupDisplay(_EGLDisplay *disp)
{
- EGLint i;
-
if (disp->Configs) {
- for (i = 0; i < disp->NumConfigs; i++)
- free(disp->Configs[i]);
- free(disp->Configs);
+ _eglDestroyArray(disp->Configs, free);
disp->Configs = NULL;
- disp->NumConfigs = 0;
}
/* XXX incomplete */
/**
- * Link a context to a display and return the handle of the link.
- * The handle can be passed to client directly.
+ * Return EGL_TRUE if the given handle is a valid handle to a display.
*/
-EGLContext
-_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy)
+EGLBoolean
+_eglCheckDisplayHandle(EGLDisplay dpy)
{
- ctx->Display = dpy;
- ctx->Next = dpy->ContextList;
- dpy->ContextList = ctx;
- return (EGLContext) ctx;
+ _EGLDisplay *cur;
+
+ mtx_lock(_eglGlobal.Mutex);
+ cur = _eglGlobal.DisplayList;
+ while (cur) {
+ if (cur == (_EGLDisplay *) dpy)
+ break;
+ cur = cur->Next;
+ }
+ mtx_unlock(_eglGlobal.Mutex);
+ return (cur != NULL);
}
/**
- * Unlink a linked context from its display.
- * Accessing an unlinked context should generate EGL_BAD_CONTEXT error.
+ * Return EGL_TRUE if the given resource is valid. That is, the display does
+ * own the resource.
*/
-void
-_eglUnlinkContext(_EGLContext *ctx)
+EGLBoolean
+_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
{
- _EGLContext *prev;
-
- prev = ctx->Display->ContextList;
- if (prev != ctx) {
- while (prev) {
- if (prev->Next == ctx)
- break;
- prev = prev->Next;
+ _EGLResource *list = dpy->ResourceLists[type];
+
+ if (!res)
+ return EGL_FALSE;
+
+ while (list) {
+ if (res == (void *) list) {
+ assert(list->Display == dpy);
+ break;
}
- assert(prev);
- prev->Next = ctx->Next;
- }
- else {
- ctx->Display->ContextList = ctx->Next;
+ list = list->Next;
}
- ctx->Next = NULL;
- ctx->Display = NULL;
+ return (list != NULL);
}
/**
- * Link a surface to a display and return the handle of the link.
- * The handle can be passed to client directly.
+ * Initialize a display resource. The size of the subclass object is
+ * specified.
+ *
+ * This is supposed to be called from the initializers of subclasses, such as
+ * _eglInitContext or _eglInitSurface.
*/
-EGLSurface
-_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy)
+void
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
{
- surf->Display = dpy;
- surf->Next = dpy->SurfaceList;
- dpy->SurfaceList = surf;
- return (EGLSurface) surf;
+ memset(res, 0, size);
+ res->Display = dpy;
+ res->RefCount = 1;
}
/**
- * Unlink a linked surface from its display.
- * Accessing an unlinked surface should generate EGL_BAD_SURFACE error.
+ * Increment reference count for the resource.
*/
void
-_eglUnlinkSurface(_EGLSurface *surf)
+_eglGetResource(_EGLResource *res)
{
- _EGLSurface *prev;
+ assert(res && res->RefCount > 0);
+ /* hopefully a resource is always manipulated with its display locked */
+ res->RefCount++;
+}
+
+
+/**
+ * Decrement reference count for the resource.
+ */
+EGLBoolean
+_eglPutResource(_EGLResource *res)
+{
+ assert(res && res->RefCount > 0);
+ res->RefCount--;
+ return (!res->RefCount);
+}
+
- prev = surf->Display->SurfaceList;
- if (prev != surf) {
+/**
+ * Link a resource to its display.
+ */
+void
+_eglLinkResource(_EGLResource *res, _EGLResourceType type)
+{
+ assert(res->Display);
+
+ res->IsLinked = EGL_TRUE;
+ res->Next = res->Display->ResourceLists[type];
+ res->Display->ResourceLists[type] = res;
+ _eglGetResource(res);
+}
+
+
+/**
+ * Unlink a linked resource from its display.
+ */
+void
+_eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
+{
+ _EGLResource *prev;
+
+ prev = res->Display->ResourceLists[type];
+ if (prev != res) {
while (prev) {
- if (prev->Next == surf)
+ if (prev->Next == res)
break;
prev = prev->Next;
}
assert(prev);
- prev->Next = surf->Next;
+ prev->Next = res->Next;
}
else {
- prev = NULL;
- surf->Display->SurfaceList = surf->Next;
+ res->Display->ResourceLists[type] = res->Next;
}
- surf->Next = NULL;
- surf->Display = NULL;
+ res->Next = NULL;
+ res->IsLinked = EGL_FALSE;
+ _eglPutResource(res);
+
+ /* We always unlink before destroy. The driver still owns a reference */
+ assert(res->RefCount);
}
+#ifdef HAVE_X11_PLATFORM
+static EGLBoolean
+_eglParseX11DisplayAttribList(_EGLDisplay *display, const EGLint *attrib_list)
+{
+ int i;
-#ifndef _EGL_SKIP_HANDLE_CHECK
+ if (attrib_list == NULL) {
+ return EGL_TRUE;
+ }
+ for (i = 0; attrib_list[i] != EGL_NONE; i += 2) {
+ EGLint attrib = attrib_list[i];
+ EGLint value = attrib_list[i + 1];
-/**
- * Return EGL_TRUE if the given handle is a valid handle to a display.
- */
-EGLBoolean
-_eglCheckDisplayHandle(EGLDisplay dpy)
-{
- _EGLDisplay *cur;
+ /* EGL_EXT_platform_x11 recognizes exactly one attribute,
+ * EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
+ */
+ if (attrib != EGL_PLATFORM_X11_SCREEN_EXT)
+ return _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
- _eglLockMutex(_eglGlobal.Mutex);
- cur = _eglGlobal.DisplayList;
- while (cur) {
- if (cur == (_EGLDisplay *) dpy)
- break;
- cur = cur->Next;
+ display->Options.Platform = (void *)(uintptr_t)value;
}
- _eglUnlockMutex(_eglGlobal.Mutex);
- return (cur != NULL);
-}
+ return EGL_TRUE;
+}
-/**
- * Return EGL_TRUE if the given handle is a valid handle to a context.
- */
-EGLBoolean
-_eglCheckContextHandle(EGLContext ctx, _EGLDisplay *dpy)
+_EGLDisplay*
+_eglGetX11Display(Display *native_display,
+ const EGLint *attrib_list)
{
- _EGLContext *cur = NULL;
+ _EGLDisplay *display = _eglFindDisplay(_EGL_PLATFORM_X11,
+ native_display);
- if (dpy)
- cur = dpy->ContextList;
- while (cur) {
- if (cur == (_EGLContext *) ctx) {
- assert(cur->Display == dpy);
- break;
- }
- cur = cur->Next;
+ if (!display) {
+ _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
+ return NULL;
}
- return (cur != NULL);
-}
+ if (!_eglParseX11DisplayAttribList(display, attrib_list)) {
+ return NULL;
+ }
-/**
- * Return EGL_TRUE if the given handle is a valid handle to a surface.
- */
-EGLBoolean
-_eglCheckSurfaceHandle(EGLSurface surf, _EGLDisplay *dpy)
+ return display;
+}
+#endif /* HAVE_X11_PLATFORM */
+
+#ifdef HAVE_DRM_PLATFORM
+_EGLDisplay*
+_eglGetGbmDisplay(struct gbm_device *native_display,
+ const EGLint *attrib_list)
{
- _EGLSurface *cur = NULL;
+ /* EGL_MESA_platform_gbm recognizes no attributes. */
+ if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
+ _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
+ return NULL;
+ }
- if (dpy)
- cur = dpy->SurfaceList;
- while (cur) {
- if (cur == (_EGLSurface *) surf) {
- assert(cur->Display == dpy);
- break;
- }
- cur = cur->Next;
+ return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display);
+}
+#endif /* HAVE_DRM_PLATFORM */
+
+#ifdef HAVE_WAYLAND_PLATFORM
+_EGLDisplay*
+_eglGetWaylandDisplay(struct wl_display *native_display,
+ const EGLint *attrib_list)
+{
+ /* EGL_EXT_platform_wayland recognizes no attributes. */
+ if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
+ _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
+ return NULL;
}
- return (cur != NULL);
+
+ return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display);
}
+#endif /* HAVE_WAYLAND_PLATFORM */
+#ifdef HAVE_SURFACELESS_PLATFORM
+_EGLDisplay*
+_eglGetSurfacelessDisplay(void *native_display,
+ const EGLint *attrib_list)
+{
+ /* This platform has no native display. */
+ if (native_display != NULL) {
+ _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
+ return NULL;
+ }
-#endif /* !_EGL_SKIP_HANDLE_CHECK */
+ /* This platform recognizes no display attributes. */
+ if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
+ _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
+ return NULL;
+ }
+
+ return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display);
+}
+#endif /* HAVE_SURFACELESS_PLATFORM */
projects / mesa.git / blobdiff