X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fmain%2Fegldisplay.c;h=1d05e57c4296c33ed0822c5fd8aa3b6af12b53f3;hb=f8e6d19f3f40931be741b44d3edf210c38e13f0f;hp=30a49a25ae09c4b8fa4dcac008c83a94521ae53f;hpb=34d8c13bff05de200dbad70d0798519108e186f2;p=mesa.git

diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 30a49a25ae0..1d05e57c429 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -1,3 +1,33 @@
+/**************************************************************************
+ *
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * 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.
  */
@@ -10,131 +40,244 @@
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglstring.h"
 #include "eglmutex.h"
 #include "egllog.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
+#ifdef HAVE_FBDEV_PLATFORM
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
 
 /**
- * Finish display management.
+ * Map --with-egl-platforms names to platform types.
  */
-void
-_eglFiniDisplay(void)
+static const struct {
+   _EGLPlatformType platform;
+   const char *name;
+} egl_platforms[_EGL_NUM_PLATFORMS] = {
+   { _EGL_PLATFORM_WINDOWS, "gdi" },
+   { _EGL_PLATFORM_X11, "x11" },
+   { _EGL_PLATFORM_WAYLAND, "wayland" },
+   { _EGL_PLATFORM_DRM, "drm" },
+   { _EGL_PLATFORM_FBDEV, "fbdev" },
+   { _EGL_PLATFORM_ANDROID, "android" }
+};
+
+
+/**
+ * Return the native platform by parsing EGL_PLATFORM.
+ */
+static _EGLPlatformType
+_eglGetNativePlatformFromEnv(void)
 {
-   _EGLDisplay *dpyList, *dpy;
+   _EGLPlatformType plat = _EGL_INVALID_PLATFORM;
+   const char *plat_name;
+   EGLint i;
 
-   /* atexit function is called with global mutex locked */
-   dpyList = _eglGlobal.DisplayList;
-   while (dpyList) {
-      /* pop list head */
-      dpy = dpyList;
-      dpyList = dpyList->Next;
+   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;
 
-      if (dpy->ContextList || dpy->SurfaceList)
-         _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
+   for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
+      if (strcmp(egl_platforms[i].name, plat_name) == 0) {
+         plat = egl_platforms[i].platform;
+         break;
+      }
+   }
 
-      free(dpy);
+   return plat;
+}
+
+
+/**
+ * Perform validity checks on a generic pointer.
+ */
+static EGLBoolean
+_eglPointerIsDereferencable(void *p)
+{
+#ifdef HAVE_MINCORE
+   uintptr_t addr = (uintptr_t) p;
+   unsigned char valid = 0;
+   const long page_size = getpagesize();
+
+   if (p == NULL)
+      return EGL_FALSE;
+
+   /* 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;
    }
-   _eglGlobal.DisplayList = NULL;
+
+   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(EGLNativeDisplayType nativeDisplay)
 {
-   _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
-   if (dpy) {
-      dpy->NativeDisplay = nativeDisplay;
-#if defined(_EGL_PLATFORM_X)
-      dpy->Xdpy = (Display *) nativeDisplay;
+#ifdef HAVE_FBDEV_PLATFORM
+   struct stat buf;
 #endif
 
-      dpy->DriverName = _eglPreloadDriver(dpy);
-      if (!dpy->DriverName) {
-         free(dpy);
-         return NULL;
-      }
+   if (nativeDisplay == EGL_DEFAULT_DISPLAY)
+      return _EGL_INVALID_PLATFORM;
+
+#ifdef HAVE_FBDEV_PLATFORM
+   /* fbdev is the only platform that can be a file descriptor. */
+   if (fstat((intptr_t) nativeDisplay, &buf) == 0 && S_ISCHR(buf.st_mode))
+      return _EGL_PLATFORM_FBDEV;
+#endif
+
+   if (_eglPointerIsDereferencable(nativeDisplay)) {
+      void *first_pointer = *(void **) nativeDisplay;
+
+#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
    }
-   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(EGLNativeDisplayType nativeDisplay)
 {
-   _eglLockMutex(_eglGlobal.Mutex);
+   static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM;
+   char *detection_method = NULL;
+
+   if (native_platform == _EGL_INVALID_PLATFORM) {
+      native_platform = _eglGetNativePlatformFromEnv();
+      detection_method = "environment overwrite";
+      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";
+         }
+      }
+   }
 
-   dpy->Next = _eglGlobal.DisplayList;
-   _eglGlobal.DisplayList = dpy;
+   if (detection_method != NULL)
+      _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)",
+              egl_platforms[native_platform].name, detection_method);
 
-   _eglUnlockMutex(_eglGlobal.Mutex);
-
-   return (EGLDisplay) dpy;
+   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;
 
+   if (plat == _EGL_INVALID_PLATFORM)
+      return NULL;
+
    _eglLockMutex(_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;
    }
 
+   /* create a new display */
+   if (!dpy) {
+      dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
+      if (dpy) {
+         _eglInitMutex(&dpy->Mutex);
+         dpy->Platform = plat;
+         dpy->PlatformDisplay = plat_dpy;
+
+         /* add to the display list */ 
+         dpy->Next = _eglGlobal.DisplayList;
+         _eglGlobal.DisplayList = dpy;
+      }
+   }
+
    _eglUnlockMutex(_eglGlobal.Mutex);
 
-   return NULL;
+   return dpy;
 }
 
 
@@ -144,29 +287,27 @@ _eglFindDisplay(NativeDisplayType nativeDisplay)
 void
 _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
 {
-   _EGLContext *contexts;
-   _EGLSurface *surfaces;
-
-   contexts = display->ContextList;
-   surfaces = display->SurfaceList;
+   _EGLResource *list;
 
-   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]);
 }
 
 
@@ -177,14 +318,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 */
@@ -192,151 +328,126 @@ _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;
+
+   _eglLockMutex(_eglGlobal.Mutex);
+   cur = _eglGlobal.DisplayList;
+   while (cur) {
+      if (cur == (_EGLDisplay *) dpy)
+         break;
+      cur = cur->Next;
+   }
+   _eglUnlockMutex(_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.
  */
-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;
-
-   prev = surf->Display->SurfaceList;
-   if (prev != surf) {
-      while (prev) {
-         if (prev->Next == surf)
-            break;
-         prev = prev->Next;
-      }
-      assert(prev);
-      prev->Next = surf->Next;
-   }
-   else {
-      prev = NULL;
-      surf->Display->SurfaceList = surf->Next;
-   }
-
-   surf->Next = NULL;
-   surf->Display = NULL;
+   assert(res && res->RefCount > 0);
+   /* hopefully a resource is always manipulated with its display locked */
+   res->RefCount++;
 }
 
 
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
 /**
- * Return EGL_TRUE if the given handle is a valid handle to a display.
+ * Decrement reference count for the resource.
  */
 EGLBoolean
-_eglCheckDisplayHandle(EGLDisplay dpy)
+_eglPutResource(_EGLResource *res)
 {
-   _EGLDisplay *cur;
-
-   _eglLockMutex(_eglGlobal.Mutex);
-   cur = _eglGlobal.DisplayList;
-   while (cur) {
-      if (cur == (_EGLDisplay *) dpy)
-         break;
-      cur = cur->Next;
-   }
-   _eglUnlockMutex(_eglGlobal.Mutex);
-   return (cur != NULL);
+   assert(res && res->RefCount > 0);
+   res->RefCount--;
+   return (!res->RefCount);
 }
 
 
 /**
- * Return EGL_TRUE if the given handle is a valid handle to a context.
+ * Link a resource to its display.
  */
-EGLBoolean
-_eglCheckContextHandle(EGLContext ctx, _EGLDisplay *dpy)
+void
+_eglLinkResource(_EGLResource *res, _EGLResourceType type)
 {
-   _EGLContext *cur;
+   assert(res->Display);
 
-   cur = dpy->ContextList;
-   while (cur) {
-      if (cur == (_EGLContext *) ctx) {
-         assert(cur->Display == dpy);
-         break;
-      }
-      cur = cur->Next;
-   }
-   return (cur != NULL);
+   res->IsLinked = EGL_TRUE;
+   res->Next = res->Display->ResourceLists[type];
+   res->Display->ResourceLists[type] = res;
+   _eglGetResource(res);
 }
 
 
 /**
- * Return EGL_TRUE if the given handle is a valid handle to a surface.
+ * Unlink a linked resource from its display.
  */
-EGLBoolean
-_eglCheckSurfaceHandle(EGLSurface surf, _EGLDisplay *dpy)
+void
+_eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
 {
-   _EGLSurface *cur;
+   _EGLResource *prev;
 
-   cur = dpy->SurfaceList;
-   while (cur) {
-      if (cur == (_EGLSurface *) surf) {
-         assert(cur->Display == dpy);
-         break;
+   prev = res->Display->ResourceLists[type];
+   if (prev != res) {
+      while (prev) {
+         if (prev->Next == res)
+            break;
+         prev = prev->Next;
       }
-      cur = cur->Next;
+      assert(prev);
+      prev->Next = res->Next;
+   }
+   else {
+      res->Display->ResourceLists[type] = res->Next;
    }
-   return (cur != NULL);
-}
 
+   res->Next = NULL;
+   res->IsLinked = EGL_FALSE;
+   _eglPutResource(res);
 
-#endif /* !_EGL_SKIP_HANDLE_CHECK */
+   /* We always unlink before destroy.  The driver still owns a reference */
+   assert(res->RefCount);
+}