1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
5 * Copyright 2010-2011 LunarG, Inc.
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
18 * of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 * DEALINGS IN THE SOFTWARE.
27 *
28 **************************************************************************/
29
30
31 /**
32 * Functions related to EGLDisplay.
33 */
34
35 #include <assert.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include "c11/threads.h"
39
40 #include "eglcontext.h"
41 #include "eglcurrent.h"
42 #include "eglsurface.h"
43 #include "egldisplay.h"
44 #include "egldriver.h"
45 #include "eglglobals.h"
46 #include "egllog.h"
47 #include "eglimage.h"
48 #include "eglsync.h"
49
50 /* Includes for _eglNativePlatformDetectNativeDisplay */
51 #ifdef HAVE_MINCORE
52 #include <unistd.h>
53 #include <sys/mman.h>
54 #endif
55 #ifdef HAVE_WAYLAND_PLATFORM
56 #include <wayland-client.h>
57 #endif
58 #ifdef HAVE_DRM_PLATFORM
59 #include <gbm.h>
60 #endif
61
62
63 /**
64 * Map --with-egl-platforms names to platform types.
65 */
66 static const struct {
67 _EGLPlatformType platform;
68 const char *name;
69 } egl_platforms[_EGL_NUM_PLATFORMS] = {
70 { _EGL_PLATFORM_X11, "x11" },
71 { _EGL_PLATFORM_WAYLAND, "wayland" },
72 { _EGL_PLATFORM_DRM, "drm" },
73 { _EGL_PLATFORM_ANDROID, "android" },
74 { _EGL_PLATFORM_HAIKU, "haiku" },
75 { _EGL_PLATFORM_SURFACELESS, "surfaceless" },
76 };
77
78
79 /**
80 * Return the native platform by parsing EGL_PLATFORM.
81 */
82 static _EGLPlatformType
_eglGetNativePlatformFromEnv(void)83 _eglGetNativePlatformFromEnv(void)
84 {
85 _EGLPlatformType plat = _EGL_INVALID_PLATFORM;
86 const char *plat_name;
87 EGLint i;
88
89 plat_name = getenv("EGL_PLATFORM");
90 /* try deprecated env variable */
91 if (!plat_name || !plat_name[0])
92 plat_name = getenv("EGL_DISPLAY");
93 if (!plat_name || !plat_name[0])
94 return _EGL_INVALID_PLATFORM;
95
96 for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
97 if (strcmp(egl_platforms[i].name, plat_name) == 0) {
98 plat = egl_platforms[i].platform;
99 break;
100 }
101 }
102
103 return plat;
104 }
105
106
107 /**
108 * Perform validity checks on a generic pointer.
109 */
110 static EGLBoolean
_eglPointerIsDereferencable(void * p)111 _eglPointerIsDereferencable(void *p)
112 {
113 #ifdef HAVE_MINCORE
114 uintptr_t addr = (uintptr_t) p;
115 unsigned char valid = 0;
116 const long page_size = getpagesize();
117
118 if (p == NULL)
119 return EGL_FALSE;
120
121 /* align addr to page_size */
122 addr &= ~(page_size - 1);
123
124 if (mincore((void *) addr, page_size, &valid) < 0) {
125 _eglLog(_EGL_DEBUG, "mincore failed: %m");
126 return EGL_FALSE;
127 }
128
129 return (valid & 0x01) == 0x01;
130 #else
131 return p != NULL;
132 #endif
133 }
134
135
136 /**
137 * Try detecting native platform with the help of native display characteristcs.
138 */
139 static _EGLPlatformType
_eglNativePlatformDetectNativeDisplay(void * nativeDisplay)140 _eglNativePlatformDetectNativeDisplay(void *nativeDisplay)
141 {
142 if (nativeDisplay == EGL_DEFAULT_DISPLAY)
143 return _EGL_INVALID_PLATFORM;
144
145 if (_eglPointerIsDereferencable(nativeDisplay)) {
146 void *first_pointer = *(void **) nativeDisplay;
147
148 (void) first_pointer; /* silence unused var warning */
149
150 #ifdef HAVE_WAYLAND_PLATFORM
151 /* wl_display is a wl_proxy, which is a wl_object.
152 * wl_object's first element points to the interfacetype. */
153 if (first_pointer == &wl_display_interface)
154 return _EGL_PLATFORM_WAYLAND;
155 #endif
156
157 #ifdef HAVE_DRM_PLATFORM
158 /* gbm has a pointer to its constructor as first element. */
159 if (first_pointer == gbm_create_device)
160 return _EGL_PLATFORM_DRM;
161 #endif
162
163 #ifdef HAVE_X11_PLATFORM
164 /* If not matched to any other platform, fallback to x11. */
165 return _EGL_PLATFORM_X11;
166 #endif
167
168 #ifdef HAVE_HAIKU_PLATFORM
169 return _EGL_PLATFORM_HAIKU;
170 #endif
171 }
172
173 return _EGL_INVALID_PLATFORM;
174 }
175
176
177 /**
178 * Return the native platform. It is the platform of the EGL native types.
179 */
180 _EGLPlatformType
_eglGetNativePlatform(void * nativeDisplay)181 _eglGetNativePlatform(void *nativeDisplay)
182 {
183 static _EGLPlatformType native_platform;
184 char *detection_method;
185
186 native_platform = _eglGetNativePlatformFromEnv();
187 detection_method = "environment overwrite";
188
189 if (native_platform == _EGL_INVALID_PLATFORM) {
190 native_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
191 detection_method = "autodetected";
192 }
193
194 if (native_platform == _EGL_INVALID_PLATFORM) {
195 native_platform = _EGL_NATIVE_PLATFORM;
196 detection_method = "build-time configuration";
197 }
198
199 _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)",
200 egl_platforms[native_platform].name, detection_method);
201
202 return native_platform;
203 }
204
205
206 /**
207 * Finish display management.
208 */
209 void
_eglFiniDisplay(void)210 _eglFiniDisplay(void)
211 {
212 _EGLDisplay *dpyList, *dpy;
213
214 /* atexit function is called with global mutex locked */
215 dpyList = _eglGlobal.DisplayList;
216 while (dpyList) {
217 EGLint i;
218
219 /* pop list head */
220 dpy = dpyList;
221 dpyList = dpyList->Next;
222
223 for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
224 if (dpy->ResourceLists[i]) {
225 _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
226 break;
227 }
228 }
229
230 free(dpy);
231 }
232 _eglGlobal.DisplayList = NULL;
233 }
234
235
236 /**
237 * Find the display corresponding to the specified native display, or create a
238 * new one.
239 */
240 _EGLDisplay *
_eglFindDisplay(_EGLPlatformType plat,void * plat_dpy)241 _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
242 {
243 _EGLDisplay *dpy;
244
245 if (plat == _EGL_INVALID_PLATFORM)
246 return NULL;
247
248 mtx_lock(_eglGlobal.Mutex);
249
250 /* search the display list first */
251 dpy = _eglGlobal.DisplayList;
252 while (dpy) {
253 if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy)
254 break;
255 dpy = dpy->Next;
256 }
257
258 /* create a new display */
259 if (!dpy) {
260 dpy = calloc(1, sizeof(_EGLDisplay));
261 if (dpy) {
262 mtx_init(&dpy->Mutex, mtx_plain);
263 dpy->Platform = plat;
264 dpy->PlatformDisplay = plat_dpy;
265
266 /* add to the display list */
267 dpy->Next = _eglGlobal.DisplayList;
268 _eglGlobal.DisplayList = dpy;
269 }
270 }
271
272 mtx_unlock(_eglGlobal.Mutex);
273
274 return dpy;
275 }
276
277
278 /**
279 * Destroy the contexts and surfaces that are linked to the display.
280 */
281 void
_eglReleaseDisplayResources(_EGLDriver * drv,_EGLDisplay * display)282 _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
283 {
284 _EGLResource *list;
285
286 list = display->ResourceLists[_EGL_RESOURCE_CONTEXT];
287 while (list) {
288 _EGLContext *ctx = (_EGLContext *) list;
289 list = list->Next;
290
291 _eglUnlinkContext(ctx);
292 drv->API.DestroyContext(drv, display, ctx);
293 }
294 assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
295
296 list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
297 while (list) {
298 _EGLSurface *surf = (_EGLSurface *) list;
299 list = list->Next;
300
301 _eglUnlinkSurface(surf);
302 drv->API.DestroySurface(drv, display, surf);
303 }
304 assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
305
306 list = display->ResourceLists[_EGL_RESOURCE_IMAGE];
307 while (list) {
308 _EGLImage *image = (_EGLImage *) list;
309 list = list->Next;
310
311 _eglUnlinkImage(image);
312 drv->API.DestroyImageKHR(drv, display, image);
313 }
314 assert(!display->ResourceLists[_EGL_RESOURCE_IMAGE]);
315
316 list = display->ResourceLists[_EGL_RESOURCE_SYNC];
317 while (list) {
318 _EGLSync *sync = (_EGLSync *) list;
319 list = list->Next;
320
321 _eglUnlinkSync(sync);
322 drv->API.DestroySyncKHR(drv, display, sync);
323 }
324 assert(!display->ResourceLists[_EGL_RESOURCE_SYNC]);
325 }
326
327
328 /**
329 * Free all the data hanging of an _EGLDisplay object, but not
330 * the object itself.
331 */
332 void
_eglCleanupDisplay(_EGLDisplay * disp)333 _eglCleanupDisplay(_EGLDisplay *disp)
334 {
335 if (disp->Configs) {
336 _eglDestroyArray(disp->Configs, free);
337 disp->Configs = NULL;
338 }
339
340 /* XXX incomplete */
341 }
342
343
344 /**
345 * Return EGL_TRUE if the given handle is a valid handle to a display.
346 */
347 EGLBoolean
_eglCheckDisplayHandle(EGLDisplay dpy)348 _eglCheckDisplayHandle(EGLDisplay dpy)
349 {
350 _EGLDisplay *cur;
351
352 mtx_lock(_eglGlobal.Mutex);
353 cur = _eglGlobal.DisplayList;
354 while (cur) {
355 if (cur == (_EGLDisplay *) dpy)
356 break;
357 cur = cur->Next;
358 }
359 mtx_unlock(_eglGlobal.Mutex);
360 return (cur != NULL);
361 }
362
363
364 /**
365 * Return EGL_TRUE if the given resource is valid. That is, the display does
366 * own the resource.
367 */
368 EGLBoolean
_eglCheckResource(void * res,_EGLResourceType type,_EGLDisplay * dpy)369 _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
370 {
371 _EGLResource *list = dpy->ResourceLists[type];
372
373 if (!res)
374 return EGL_FALSE;
375
376 while (list) {
377 if (res == (void *) list) {
378 assert(list->Display == dpy);
379 break;
380 }
381 list = list->Next;
382 }
383
384 return (list != NULL);
385 }
386
387
388 /**
389 * Initialize a display resource. The size of the subclass object is
390 * specified.
391 *
392 * This is supposed to be called from the initializers of subclasses, such as
393 * _eglInitContext or _eglInitSurface.
394 */
395 void
_eglInitResource(_EGLResource * res,EGLint size,_EGLDisplay * dpy)396 _eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
397 {
398 memset(res, 0, size);
399 res->Display = dpy;
400 res->RefCount = 1;
401 }
402
403
404 /**
405 * Increment reference count for the resource.
406 */
407 void
_eglGetResource(_EGLResource * res)408 _eglGetResource(_EGLResource *res)
409 {
410 assert(res && res->RefCount > 0);
411 /* hopefully a resource is always manipulated with its display locked */
412 res->RefCount++;
413 }
414
415
416 /**
417 * Decrement reference count for the resource.
418 */
419 EGLBoolean
_eglPutResource(_EGLResource * res)420 _eglPutResource(_EGLResource *res)
421 {
422 assert(res && res->RefCount > 0);
423 res->RefCount--;
424 return (!res->RefCount);
425 }
426
427
428 /**
429 * Link a resource to its display.
430 */
431 void
_eglLinkResource(_EGLResource * res,_EGLResourceType type)432 _eglLinkResource(_EGLResource *res, _EGLResourceType type)
433 {
434 assert(res->Display);
435
436 res->IsLinked = EGL_TRUE;
437 res->Next = res->Display->ResourceLists[type];
438 res->Display->ResourceLists[type] = res;
439 _eglGetResource(res);
440 }
441
442
443 /**
444 * Unlink a linked resource from its display.
445 */
446 void
_eglUnlinkResource(_EGLResource * res,_EGLResourceType type)447 _eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
448 {
449 _EGLResource *prev;
450
451 prev = res->Display->ResourceLists[type];
452 if (prev != res) {
453 while (prev) {
454 if (prev->Next == res)
455 break;
456 prev = prev->Next;
457 }
458 assert(prev);
459 prev->Next = res->Next;
460 }
461 else {
462 res->Display->ResourceLists[type] = res->Next;
463 }
464
465 res->Next = NULL;
466 res->IsLinked = EGL_FALSE;
467 _eglPutResource(res);
468
469 /* We always unlink before destroy. The driver still owns a reference */
470 assert(res->RefCount);
471 }
472
473 #ifdef HAVE_X11_PLATFORM
474 static EGLBoolean
_eglParseX11DisplayAttribList(const EGLint * attrib_list)475 _eglParseX11DisplayAttribList(const EGLint *attrib_list)
476 {
477 int i;
478
479 if (attrib_list == NULL) {
480 return EGL_TRUE;
481 }
482
483 for (i = 0; attrib_list[i] != EGL_NONE; i += 2) {
484 EGLint attrib = attrib_list[i];
485 EGLint value = attrib_list[i + 1];
486
487 /* EGL_EXT_platform_x11 recognizes exactly one attribute,
488 * EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
489 *
490 * Mesa supports connecting to only the default screen, so we reject
491 * screen != 0.
492 */
493 if (attrib != EGL_PLATFORM_X11_SCREEN_EXT || value != 0) {
494 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
495 return EGL_FALSE;
496 }
497 }
498
499 return EGL_TRUE;
500 }
501
502 _EGLDisplay*
_eglGetX11Display(Display * native_display,const EGLint * attrib_list)503 _eglGetX11Display(Display *native_display,
504 const EGLint *attrib_list)
505 {
506 if (!_eglParseX11DisplayAttribList(attrib_list)) {
507 return NULL;
508 }
509
510 return _eglFindDisplay(_EGL_PLATFORM_X11, native_display);
511 }
512 #endif /* HAVE_X11_PLATFORM */
513
514 #ifdef HAVE_DRM_PLATFORM
515 _EGLDisplay*
_eglGetGbmDisplay(struct gbm_device * native_display,const EGLint * attrib_list)516 _eglGetGbmDisplay(struct gbm_device *native_display,
517 const EGLint *attrib_list)
518 {
519 /* EGL_MESA_platform_gbm recognizes no attributes. */
520 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
521 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
522 return NULL;
523 }
524
525 return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display);
526 }
527 #endif /* HAVE_DRM_PLATFORM */
528
529 #ifdef HAVE_WAYLAND_PLATFORM
530 _EGLDisplay*
_eglGetWaylandDisplay(struct wl_display * native_display,const EGLint * attrib_list)531 _eglGetWaylandDisplay(struct wl_display *native_display,
532 const EGLint *attrib_list)
533 {
534 /* EGL_EXT_platform_wayland recognizes no attributes. */
535 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
536 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
537 return NULL;
538 }
539
540 return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display);
541 }
542 #endif /* HAVE_WAYLAND_PLATFORM */
543
544 #ifdef HAVE_SURFACELESS_PLATFORM
545 _EGLDisplay*
_eglGetSurfacelessDisplay(void * native_display,const EGLint * attrib_list)546 _eglGetSurfacelessDisplay(void *native_display,
547 const EGLint *attrib_list)
548 {
549 /* This platform has no native display. */
550 if (native_display != NULL) {
551 _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
552 return NULL;
553 }
554
555 /* This platform recognizes no display attributes. */
556 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
557 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
558 return NULL;
559 }
560
561 return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display);
562 }
563 #endif /* HAVE_SURFACELESS_PLATFORM */
564