X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fmain%2Fegldisplay.c;h=37711bd8695ea744dd18d66053e89d1946a57d0e;hb=9db5cc829f6bd7ba09f3bf0bf057b7162d05d037;hp=7f2d035c66a59999e21197359523f1bca1baa9bf;hpb=7a9f52800932c02f5b425158b4978d0c1d2f4fd3;p=mesa.git diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c index 7f2d035c66a..37711bd8695 100644 --- a/src/egl/main/egldisplay.c +++ b/src/egl/main/egldisplay.c @@ -1,3 +1,33 @@ +/************************************************************************** + * + * Copyright 2008 VMware, Inc. + * Copyright 2009-2010 Chia-I Wu + * 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. */ @@ -5,185 +35,243 @@ #include #include #include +#include "c11/threads.h" + #include "eglcontext.h" +#include "eglcurrent.h" #include "eglsurface.h" #include "egldisplay.h" #include "egldriver.h" #include "eglglobals.h" -#include "eglhash.h" -#include "eglstring.h" -#include "eglmutex.h" #include "egllog.h" +#include "eglimage.h" +#include "eglsync.h" - -static _EGL_DECLARE_MUTEX(_eglDisplayInitMutex); -static _EGLHashtable *_eglDisplayHash; +/* Includes for _eglNativePlatformDetectNativeDisplay */ +#ifdef HAVE_MINCORE +#include +#include +#endif +#ifdef HAVE_WAYLAND_PLATFORM +#include +#endif +#ifdef HAVE_DRM_PLATFORM +#include +#endif /** - * Finish display management. + * Map --with-egl-platforms names to platform types. */ -static void -_eglFiniDisplay(void) -{ - _eglLockMutex(&_eglDisplayInitMutex); - if (_eglDisplayHash) { - EGLuint key = _eglHashFirstEntry(_eglDisplayHash); - - while (key) { - _EGLDisplay *dpy = (_EGLDisplay *) - _eglHashLookup(_eglDisplayHash, key); - assert(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" }, +}; - if (dpy->ContextList || dpy->SurfaceList) - _eglLog(_EGL_DEBUG, "Display %u is destroyed with resources", key); - free(dpy); +/** + * Return the native platform by parsing EGL_PLATFORM. + */ +static _EGLPlatformType +_eglGetNativePlatformFromEnv(void) +{ + _EGLPlatformType plat = _EGL_INVALID_PLATFORM; + const char *plat_name; + EGLint i; - key = _eglHashNextEntry(_eglDisplayHash, key); + 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; + + for (i = 0; i < _EGL_NUM_PLATFORMS; i++) { + if (strcmp(egl_platforms[i].name, plat_name) == 0) { + plat = egl_platforms[i].platform; + break; } - - _eglDeleteHashTable(_eglDisplayHash); - _eglDisplayHash = NULL; } - _eglUnlockMutex(&_eglDisplayInitMutex); + + return plat; } -/* This can be avoided if hash table can be statically initialized */ -static INLINE void -_eglInitDisplay(void) +/** + * Perform validity checks on a generic pointer. + */ +static EGLBoolean +_eglPointerIsDereferencable(void *p) { - if (!_eglDisplayHash) { - _eglLockMutex(&_eglDisplayInitMutex); +#ifdef HAVE_MINCORE + uintptr_t addr = (uintptr_t) p; + unsigned char valid = 0; + const long page_size = getpagesize(); - /* check again after acquiring lock */ - if (!_eglDisplayHash) { - _eglDisplayHash = _eglNewHashTable(); + if (p == NULL) + return EGL_FALSE; - _eglAddAtExitCall(_eglFiniDisplay); - } + /* align addr to page_size */ + addr &= ~(page_size - 1); - _eglUnlockMutex(&_eglDisplayInitMutex); + if (mincore((void *) addr, page_size, &valid) < 0) { + _eglLog(_EGL_DEBUG, "mincore failed: %m"); + return EGL_FALSE; } + + 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; -#if defined(_EGL_PLATFORM_X) - dpy->Xdpy = (Display *) nativeDisplay; -#endif + if (nativeDisplay == EGL_DEFAULT_DISPLAY) + return _EGL_INVALID_PLATFORM; - dpy->DriverName = _eglPreloadDriver(dpy); - if (!dpy->DriverName) { - free(dpy); - return NULL; - } - } - return dpy; -} + if (_eglPointerIsDereferencable(nativeDisplay)) { + void *first_pointer = *(void **) nativeDisplay; + (void) first_pointer; /* silence unused var warning */ -/** - * Link a display to itself and return the handle of the link. - * The handle can be passed to client directly. - */ -EGLDisplay -_eglLinkDisplay(_EGLDisplay *dpy) -{ - EGLuint key; +#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 - _eglInitDisplay(); +#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 - key = _eglHashGenKey(_eglDisplayHash); - assert(key); - /* "link" the display to the hash table */ - _eglHashInsert(_eglDisplayHash, key, dpy); - dpy->Handle = (EGLDisplay) _eglUIntToPointer(key); +#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->Handle; + return _EGL_INVALID_PLATFORM; } /** - * Unlink a linked display from itself. - * Accessing an unlinked display should generate EGL_BAD_DISPLAY error. + * Return the native platform. It is the platform of the EGL native types. */ -void -_eglUnlinkDisplay(_EGLDisplay *dpy) +_EGLPlatformType +_eglGetNativePlatform(void *nativeDisplay) { - EGLuint key = _eglPointerToUInt((void *) dpy->Handle); + static _EGLPlatformType native_platform; + char *detection_method; - _eglInitDisplay(); + native_platform = _eglGetNativePlatformFromEnv(); + detection_method = "environment overwrite"; - _eglHashRemove(_eglDisplayHash, key); - dpy->Handle = EGL_NO_DISPLAY; -} + if (native_platform == _EGL_INVALID_PLATFORM) { + native_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay); + detection_method = "autodetected"; + } + if (native_platform == _EGL_INVALID_PLATFORM) { + native_platform = _EGL_NATIVE_PLATFORM; + detection_method = "build-time configuration"; + } -/** - * Return the handle of a linked display, or EGL_NO_DISPLAY. - */ -EGLDisplay -_eglGetDisplayHandle(_EGLDisplay *display) -{ - if (display) - return display->Handle; - else - return EGL_NO_DISPLAY; + _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)", + egl_platforms[native_platform].name, detection_method); + + return native_platform; } /** - * Lookup a handle to find the linked display. - * Return NULL if the handle has no corresponding linked display. + * Finish display management. */ -_EGLDisplay * -_eglLookupDisplay(EGLDisplay dpy) +void +_eglFiniDisplay(void) { - EGLuint key = _eglPointerToUInt((void *) dpy); + _EGLDisplay *dpyList, *dpy; + + /* atexit function is called with global mutex locked */ + dpyList = _eglGlobal.DisplayList; + while (dpyList) { + EGLint i; - _eglInitDisplay(); + /* pop list head */ + dpy = dpyList; + dpyList = dpyList->Next; - return (_EGLDisplay *) _eglHashLookup(_eglDisplayHash, key); + for (i = 0; i < _EGL_NUM_RESOURCES; i++) { + if (dpy->ResourceLists[i]) { + _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy); + break; + } + } + + 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) { - EGLuint key; + _EGLDisplay *dpy; + + if (plat == _EGL_INVALID_PLATFORM) + return NULL; - _eglInitDisplay(); + mtx_lock(_eglGlobal.Mutex); - /* Walk the hash table. Should switch to list if it is a problem. */ - key = _eglHashFirstEntry(_eglDisplayHash); - while (key) { - _EGLDisplay *dpy = (_EGLDisplay *) - _eglHashLookup(_eglDisplayHash, key); - assert(dpy); + /* search the display list first */ + dpy = _eglGlobal.DisplayList; + while (dpy) { + if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy) + break; + dpy = dpy->Next; + } - if (dpy->NativeDisplay == nativeDisplay) - return dpy; - key = _eglHashNextEntry(_eglDisplayHash, key); + /* 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; + } } - return NULL; + mtx_unlock(_eglGlobal.Mutex); + + return dpy; } @@ -193,29 +281,47 @@ _eglFindDisplay(NativeDisplayType nativeDisplay) 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]); } @@ -226,14 +332,9 @@ _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display) 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 */ @@ -241,129 +342,222 @@ _eglCleanupDisplay(_EGLDisplay *disp) /** - * 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); } /** - * Return the handle of a linked context, or EGL_NO_CONTEXT. + * 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. */ -EGLContext -_eglGetContextHandle(_EGLContext *ctx) +void +_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy) { - return (EGLContext) ((ctx && ctx->Display) ? ctx : EGL_NO_CONTEXT); + memset(res, 0, size); + res->Display = dpy; + res->RefCount = 1; } /** - * Lookup a handle to find the linked context. - * Return NULL if the handle has no corresponding linked context. + * Increment reference count for the resource. */ -_EGLContext * -_eglLookupContext(EGLContext ctx, _EGLDisplay *dpy) +void +_eglGetResource(_EGLResource *res) { - _EGLContext *context = (_EGLContext *) ctx; - return (context && context->Display) ? context : NULL; + assert(res && res->RefCount > 0); + /* hopefully a resource is always manipulated with its display locked */ + res->RefCount++; } /** - * Link a surface to a display and return the handle of the link. - * The handle can be passed to client directly. + * Decrement reference count for the resource. */ -EGLSurface -_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy) +EGLBoolean +_eglPutResource(_EGLResource *res) { - surf->Display = dpy; - surf->Next = dpy->SurfaceList; - dpy->SurfaceList = surf; - return (EGLSurface) surf; + assert(res && res->RefCount > 0); + res->RefCount--; + return (!res->RefCount); } /** - * Unlink a linked surface from its display. - * Accessing an unlinked surface should generate EGL_BAD_SURFACE error. + * Link a resource to its display. */ void -_eglUnlinkSurface(_EGLSurface *surf) +_eglLinkResource(_EGLResource *res, _EGLResourceType type) { - _EGLSurface *prev; + assert(res->Display); + + res->IsLinked = EGL_TRUE; + res->Next = res->Display->ResourceLists[type]; + res->Display->ResourceLists[type] = res; + _eglGetResource(res); +} + - prev = surf->Display->SurfaceList; - if (prev != surf) { +/** + * 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(const EGLint *attrib_list) +{ + int i; + + if (attrib_list == NULL) { + return EGL_TRUE; + } -/** - * Return the handle of a linked surface, or EGL_NO_SURFACE. - */ -EGLSurface -_eglGetSurfaceHandle(_EGLSurface *surf) + for (i = 0; attrib_list[i] != EGL_NONE; i += 2) { + EGLint attrib = attrib_list[i]; + EGLint value = attrib_list[i + 1]; + + /* EGL_EXT_platform_x11 recognizes exactly one attribute, + * EGL_PLATFORM_X11_SCREEN_EXT, which is optional. + * + * Mesa supports connecting to only the default screen, so we reject + * screen != 0. + */ + if (attrib != EGL_PLATFORM_X11_SCREEN_EXT || value != 0) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay"); + return EGL_FALSE; + } + } + + return EGL_TRUE; +} + +_EGLDisplay* +_eglGetX11Display(Display *native_display, + const EGLint *attrib_list) +{ + if (!_eglParseX11DisplayAttribList(attrib_list)) { + return NULL; + } + + return _eglFindDisplay(_EGL_PLATFORM_X11, native_display); +} +#endif /* HAVE_X11_PLATFORM */ + +#ifdef HAVE_DRM_PLATFORM +_EGLDisplay* +_eglGetGbmDisplay(struct gbm_device *native_display, + const EGLint *attrib_list) { - return (EGLSurface) ((surf && surf->Display) ? surf : EGL_NO_SURFACE); + /* EGL_MESA_platform_gbm recognizes no attributes. */ + if (attrib_list != NULL && attrib_list[0] != EGL_NONE) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay"); + return NULL; + } + + 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; + } -/** - * Lookup a handle to find the linked surface. - * Return NULL if the handle has no corresponding linked surface. - */ -_EGLSurface * -_eglLookupSurface(EGLSurface surface, _EGLDisplay *dpy) + return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display); +} +#endif /* HAVE_WAYLAND_PLATFORM */ + +#ifdef HAVE_SURFACELESS_PLATFORM +_EGLDisplay* +_eglGetSurfacelessDisplay(void *native_display, + const EGLint *attrib_list) { - _EGLSurface *surf = (_EGLSurface *) surface; - return (surf && surf->Display) ? surf : NULL; + /* This platform has no native display. */ + if (native_display != NULL) { + _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay"); + return NULL; + } + + /* 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 */