#include <assert.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
#include "c11/threads.h"
+#include "util/macros.h"
+#include "util/os_file.h"
+#include "util/u_atomic.h"
#include "eglcontext.h"
#include "eglcurrent.h"
#include "eglsurface.h"
+#include "egldevice.h"
#include "egldisplay.h"
#include "egldriver.h"
#include "eglglobals.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
/**
- * Map --with-egl-platforms names to platform types.
+ * Map build-system platform names to platform types.
*/
static const struct {
_EGLPlatformType platform;
const char *name;
-} egl_platforms[_EGL_NUM_PLATFORMS] = {
+} egl_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" },
+ { _EGL_PLATFORM_DEVICE, "device" },
};
const char *plat_name;
EGLint i;
+ static_assert(ARRAY_SIZE(egl_platforms) == _EGL_NUM_PLATFORMS,
+ "Missing platform");
+
plat_name = getenv("EGL_PLATFORM");
/* try deprecated env variable */
if (!plat_name || !plat_name[0])
if (!plat_name || !plat_name[0])
return _EGL_INVALID_PLATFORM;
- for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
+ for (i = 0; i < ARRAY_SIZE(egl_platforms); i++) {
if (strcmp(egl_platforms[i].name, plat_name) == 0) {
plat = egl_platforms[i].platform;
break;
}
}
- 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;
- }
+ if (plat == _EGL_INVALID_PLATFORM)
+ _eglLog(_EGL_WARNING, "invalid EGL_PLATFORM given");
- return (valid & 0x01) == 0x01;
-#else
- return p != NULL;
-#endif
+ return plat;
}
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 _EGL_INVALID_PLATFORM;
_EGLPlatformType
_eglGetNativePlatform(void *nativeDisplay)
{
- static _EGLPlatformType native_platform;
- char *detection_method;
-
- native_platform = _eglGetNativePlatformFromEnv();
- detection_method = "environment overwrite";
+ _EGLPlatformType detected_platform = _eglGetNativePlatformFromEnv();
+ const char *detection_method = "environment";
- if (native_platform == _EGL_INVALID_PLATFORM) {
- native_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
+ if (detected_platform == _EGL_INVALID_PLATFORM) {
+ detected_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
detection_method = "autodetected";
}
- if (native_platform == _EGL_INVALID_PLATFORM) {
- native_platform = _EGL_NATIVE_PLATFORM;
+ 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[native_platform].name, detection_method);
+ egl_platforms[detected_platform].name, detection_method);
- return native_platform;
+ return detected_platform;
}
void
_eglFiniDisplay(void)
{
- _EGLDisplay *dpyList, *dpy;
+ _EGLDisplay *dispList, *disp;
/* atexit function is called with global mutex locked */
- dpyList = _eglGlobal.DisplayList;
- while (dpyList) {
+ dispList = _eglGlobal.DisplayList;
+ while (dispList) {
EGLint i;
/* pop list head */
- dpy = dpyList;
- dpyList = dpyList->Next;
+ disp = dispList;
+ dispList = dispList->Next;
for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
- if (dpy->ResourceLists[i]) {
- _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
+ if (disp->ResourceLists[i]) {
+ _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", disp);
break;
}
}
- free(dpy);
+
+ /* The fcntl() code in _eglGetDeviceDisplay() ensures that valid fd >= 3,
+ * and invalid one is 0.
+ */
+ if (disp->Options.fd)
+ close(disp->Options.fd);
+
+ free(disp->Options.Attribs);
+ free(disp);
}
_eglGlobal.DisplayList = NULL;
}
+static EGLBoolean
+_eglSameAttribs(const EGLAttrib *a, const EGLAttrib *b)
+{
+ size_t na = _eglNumAttribs(a);
+ size_t nb = _eglNumAttribs(b);
+
+ /* different numbers of attributes must be different */
+ if (na != nb)
+ return EGL_FALSE;
+
+ /* both lists NULL are the same */
+ if (!a && !b)
+ return EGL_TRUE;
+
+ /* otherwise, compare the lists */
+ return memcmp(a, b, na * sizeof(a[0])) == 0 ? EGL_TRUE : EGL_FALSE;
+}
/**
* Find the display corresponding to the specified native display, or create a
- * new one.
+ * new one. EGL 1.5 says:
+ *
+ * Multiple calls made to eglGetPlatformDisplay with the same parameters
+ * will return the same EGLDisplay handle.
+ *
+ * We read this extremely strictly, and treat a call with NULL attribs as
+ * different from a call with attribs only equal to { EGL_NONE }. Similarly
+ * we do not sort the attribute list, so even if all attribute _values_ are
+ * identical, different attribute orders will be considered different
+ * parameters.
*/
_EGLDisplay *
-_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
+_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy,
+ const EGLAttrib *attrib_list)
{
- _EGLDisplay *dpy;
+ _EGLDisplay *disp;
+ size_t num_attribs;
if (plat == _EGL_INVALID_PLATFORM)
return NULL;
mtx_lock(_eglGlobal.Mutex);
/* search the display list first */
- dpy = _eglGlobal.DisplayList;
- while (dpy) {
- if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy)
+ for (disp = _eglGlobal.DisplayList; disp; disp = disp->Next) {
+ if (disp->Platform == plat && disp->PlatformDisplay == plat_dpy &&
+ _eglSameAttribs(disp->Options.Attribs, attrib_list))
break;
- dpy = dpy->Next;
}
/* 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;
+ if (!disp) {
+ disp = calloc(1, sizeof(_EGLDisplay));
+ if (disp) {
+ mtx_init(&disp->Mutex, mtx_plain);
+ disp->Platform = plat;
+ disp->PlatformDisplay = plat_dpy;
+ num_attribs = _eglNumAttribs(attrib_list);
+ if (num_attribs) {
+ disp->Options.Attribs = calloc(num_attribs, sizeof(EGLAttrib));
+ if (!disp->Options.Attribs) {
+ free(disp);
+ disp = NULL;
+ goto out;
+ }
+ memcpy(disp->Options.Attribs, attrib_list,
+ num_attribs * sizeof(EGLAttrib));
+ }
+ /* add to the display list */
+ disp->Next = _eglGlobal.DisplayList;
+ _eglGlobal.DisplayList = disp;
}
}
+out:
mtx_unlock(_eglGlobal.Mutex);
- return dpy;
+ return disp;
}
* own the resource.
*/
EGLBoolean
-_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
+_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *disp)
{
- _EGLResource *list = dpy->ResourceLists[type];
+ _EGLResource *list = disp->ResourceLists[type];
if (!res)
return EGL_FALSE;
while (list) {
if (res == (void *) list) {
- assert(list->Display == dpy);
+ assert(list->Display == disp);
break;
}
list = list->Next;
* _eglInitContext or _eglInitSurface.
*/
void
-_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *disp)
{
memset(res, 0, size);
- res->Display = dpy;
+ res->Display = disp;
res->RefCount = 1;
}
}
#ifdef HAVE_X11_PLATFORM
-static EGLBoolean
-_eglParseX11DisplayAttribList(_EGLDisplay *display, const EGLint *attrib_list)
-{
- int i;
-
- 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];
-
- /* EGL_EXT_platform_x11 recognizes exactly one attribute,
- * EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
- */
- if (attrib == EGL_PLATFORM_X11_SCREEN_EXT) {
- display->Options.Platform = (void *)value;
- } else {
- _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
- return EGL_FALSE;
- }
- }
-
- return EGL_TRUE;
-}
-
_EGLDisplay*
_eglGetX11Display(Display *native_display,
- const EGLint *attrib_list)
+ const EGLAttrib *attrib_list)
{
- _EGLDisplay *display = _eglFindDisplay(_EGL_PLATFORM_X11,
- native_display);
-
- if (!display)
- _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
-
- if (!_eglParseX11DisplayAttribList(display, attrib_list)) {
- return NULL;
+ /* EGL_EXT_platform_x11 recognizes exactly one attribute,
+ * EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
+ */
+ if (attrib_list != NULL) {
+ for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
+ if (attrib_list[i] != EGL_PLATFORM_X11_SCREEN_EXT) {
+ _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
+ return NULL;
+ }
+ }
}
-
- return display;
+ return _eglFindDisplay(_EGL_PLATFORM_X11, native_display, attrib_list);
}
#endif /* HAVE_X11_PLATFORM */
#ifdef HAVE_DRM_PLATFORM
_EGLDisplay*
_eglGetGbmDisplay(struct gbm_device *native_display,
- const EGLint *attrib_list)
+ const EGLAttrib *attrib_list)
{
/* EGL_MESA_platform_gbm recognizes no attributes. */
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
return NULL;
}
- return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display);
+ return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display, attrib_list);
}
#endif /* HAVE_DRM_PLATFORM */
#ifdef HAVE_WAYLAND_PLATFORM
_EGLDisplay*
_eglGetWaylandDisplay(struct wl_display *native_display,
- const EGLint *attrib_list)
+ const EGLAttrib *attrib_list)
{
/* EGL_EXT_platform_wayland recognizes no attributes. */
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
return NULL;
}
- return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display);
+ return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display, attrib_list);
}
#endif /* HAVE_WAYLAND_PLATFORM */
-#ifdef HAVE_SURFACELESS_PLATFORM
_EGLDisplay*
_eglGetSurfacelessDisplay(void *native_display,
- const EGLint *attrib_list)
+ const EGLAttrib *attrib_list)
{
/* This platform has no native display. */
if (native_display != NULL) {
return NULL;
}
- return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display);
+ return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display,
+ attrib_list);
+}
+
+#ifdef HAVE_ANDROID_PLATFORM
+_EGLDisplay*
+_eglGetAndroidDisplay(void *native_display,
+ const EGLAttrib *attrib_list)
+{
+
+ /* 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_ANDROID, native_display,
+ attrib_list);
+}
+#endif /* HAVE_ANDROID_PLATFORM */
+
+_EGLDisplay*
+_eglGetDeviceDisplay(void *native_display,
+ const EGLAttrib *attrib_list)
+{
+ _EGLDevice *dev;
+ _EGLDisplay *display;
+ int fd = -1;
+
+ dev = _eglLookupDevice(native_display);
+ if (!dev) {
+ _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
+ return NULL;
+ }
+
+ if (attrib_list) {
+ for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
+ EGLAttrib attrib = attrib_list[i];
+ EGLAttrib value = attrib_list[i + 1];
+
+ /* EGL_EXT_platform_device does not recognize any attributes,
+ * EGL_EXT_device_drm adds the optional EGL_DRM_MASTER_FD_EXT.
+ */
+
+ if (!_eglDeviceSupports(dev, _EGL_DEVICE_DRM) ||
+ attrib != EGL_DRM_MASTER_FD_EXT) {
+ _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
+ return NULL;
+ }
+
+ fd = (int) value;
+ }
+ }
+
+ display = _eglFindDisplay(_EGL_PLATFORM_DEVICE, native_display, attrib_list);
+ if (!display) {
+ _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
+ return NULL;
+ }
+
+ /* If the fd is explicitly provided and we did not dup() it yet, do so.
+ * The spec mandates that we do so, since we'll need it past the
+ * eglGetPlatformDispay call.
+ *
+ * The new fd is guaranteed to be 3 or greater.
+ */
+ if (fd != -1 && display->Options.fd == 0) {
+ display->Options.fd = os_dupfd_cloexec(fd);
+ if (display->Options.fd == -1) {
+ /* Do not (really) need to teardown the display */
+ _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
+ return NULL;
+ }
+ }
+
+ return display;
}
-#endif /* HAVE_SURFACELESS_PLATFORM */
projects / mesa.git / blobdiff