ac05f6f9fff14805519678f9ea8044c4915ccdb8
[mesa.git] / src / egl / main / egldisplay.c
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 <unistd.h>
39 #include <fcntl.h>
40 #include "c11/threads.h"
41 #include "util/macros.h"
42 #include "util/os_file.h"
43 #include "util/u_atomic.h"
44
45 #include "eglcontext.h"
46 #include "eglcurrent.h"
47 #include "eglsurface.h"
48 #include "egldevice.h"
49 #include "egldisplay.h"
50 #include "egldriver.h"
51 #include "eglglobals.h"
52 #include "egllog.h"
53 #include "eglimage.h"
54 #include "eglsync.h"
55
56 /* Includes for _eglNativePlatformDetectNativeDisplay */
57 #ifdef HAVE_WAYLAND_PLATFORM
58 #include <wayland-client.h>
59 #endif
60 #ifdef HAVE_DRM_PLATFORM
61 #include <gbm.h>
62 #endif
63
64
65 /**
66 * Map build-system platform names to platform types.
67 */
68 static const struct {
69 _EGLPlatformType platform;
70 const char *name;
71 } egl_platforms[] = {
72 { _EGL_PLATFORM_X11, "x11" },
73 { _EGL_PLATFORM_WAYLAND, "wayland" },
74 { _EGL_PLATFORM_DRM, "drm" },
75 { _EGL_PLATFORM_ANDROID, "android" },
76 { _EGL_PLATFORM_HAIKU, "haiku" },
77 { _EGL_PLATFORM_SURFACELESS, "surfaceless" },
78 { _EGL_PLATFORM_DEVICE, "device" },
79 };
80
81
82 /**
83 * Return the native platform by parsing EGL_PLATFORM.
84 */
85 static _EGLPlatformType
86 _eglGetNativePlatformFromEnv(void)
87 {
88 _EGLPlatformType plat = _EGL_INVALID_PLATFORM;
89 const char *plat_name;
90 EGLint i;
91
92 static_assert(ARRAY_SIZE(egl_platforms) == _EGL_NUM_PLATFORMS,
93 "Missing platform");
94
95 plat_name = getenv("EGL_PLATFORM");
96 /* try deprecated env variable */
97 if (!plat_name || !plat_name[0])
98 plat_name = getenv("EGL_DISPLAY");
99 if (!plat_name || !plat_name[0])
100 return _EGL_INVALID_PLATFORM;
101
102 for (i = 0; i < ARRAY_SIZE(egl_platforms); i++) {
103 if (strcmp(egl_platforms[i].name, plat_name) == 0) {
104 plat = egl_platforms[i].platform;
105 break;
106 }
107 }
108
109 if (plat == _EGL_INVALID_PLATFORM)
110 _eglLog(_EGL_WARNING, "invalid EGL_PLATFORM given");
111
112 return plat;
113 }
114
115
116 /**
117 * Try detecting native platform with the help of native display characteristcs.
118 */
119 static _EGLPlatformType
120 _eglNativePlatformDetectNativeDisplay(void *nativeDisplay)
121 {
122 if (nativeDisplay == EGL_DEFAULT_DISPLAY)
123 return _EGL_INVALID_PLATFORM;
124
125 if (_eglPointerIsDereferencable(nativeDisplay)) {
126 void *first_pointer = *(void **) nativeDisplay;
127
128 (void) first_pointer; /* silence unused var warning */
129
130 #ifdef HAVE_WAYLAND_PLATFORM
131 /* wl_display is a wl_proxy, which is a wl_object.
132 * wl_object's first element points to the interfacetype. */
133 if (first_pointer == &wl_display_interface)
134 return _EGL_PLATFORM_WAYLAND;
135 #endif
136
137 #ifdef HAVE_DRM_PLATFORM
138 /* gbm has a pointer to its constructor as first element. */
139 if (first_pointer == gbm_create_device)
140 return _EGL_PLATFORM_DRM;
141 #endif
142 }
143
144 return _EGL_INVALID_PLATFORM;
145 }
146
147
148 /**
149 * Return the native platform. It is the platform of the EGL native types.
150 */
151 _EGLPlatformType
152 _eglGetNativePlatform(void *nativeDisplay)
153 {
154 _EGLPlatformType detected_platform = _eglGetNativePlatformFromEnv();
155 const char *detection_method = "environment";
156
157 if (detected_platform == _EGL_INVALID_PLATFORM) {
158 detected_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
159 detection_method = "autodetected";
160 }
161
162 if (detected_platform == _EGL_INVALID_PLATFORM) {
163 detected_platform = _EGL_NATIVE_PLATFORM;
164 detection_method = "build-time configuration";
165 }
166
167 _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)",
168 egl_platforms[detected_platform].name, detection_method);
169
170 return detected_platform;
171 }
172
173
174 /**
175 * Finish display management.
176 */
177 void
178 _eglFiniDisplay(void)
179 {
180 _EGLDisplay *dispList, *disp;
181
182 /* atexit function is called with global mutex locked */
183 dispList = _eglGlobal.DisplayList;
184 while (dispList) {
185 EGLint i;
186
187 /* pop list head */
188 disp = dispList;
189 dispList = dispList->Next;
190
191 for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
192 if (disp->ResourceLists[i]) {
193 _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", disp);
194 break;
195 }
196 }
197
198
199 /* The fcntl() code in _eglGetDeviceDisplay() ensures that valid fd >= 3,
200 * and invalid one is 0.
201 */
202 if (disp->Options.fd)
203 close(disp->Options.fd);
204
205 free(disp->Options.Attribs);
206 free(disp);
207 }
208 _eglGlobal.DisplayList = NULL;
209 }
210
211 static EGLBoolean
212 _eglSameAttribs(const EGLAttrib *a, const EGLAttrib *b)
213 {
214 size_t na = _eglNumAttribs(a);
215 size_t nb = _eglNumAttribs(b);
216
217 /* different numbers of attributes must be different */
218 if (na != nb)
219 return EGL_FALSE;
220
221 /* both lists NULL are the same */
222 if (!a && !b)
223 return EGL_TRUE;
224
225 /* otherwise, compare the lists */
226 return memcmp(a, b, na * sizeof(a[0])) == 0 ? EGL_TRUE : EGL_FALSE;
227 }
228
229 /**
230 * Find the display corresponding to the specified native display, or create a
231 * new one. EGL 1.5 says:
232 *
233 * Multiple calls made to eglGetPlatformDisplay with the same parameters
234 * will return the same EGLDisplay handle.
235 *
236 * We read this extremely strictly, and treat a call with NULL attribs as
237 * different from a call with attribs only equal to { EGL_NONE }. Similarly
238 * we do not sort the attribute list, so even if all attribute _values_ are
239 * identical, different attribute orders will be considered different
240 * parameters.
241 */
242 _EGLDisplay *
243 _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy,
244 const EGLAttrib *attrib_list)
245 {
246 _EGLDisplay *disp;
247 size_t num_attribs;
248
249 if (plat == _EGL_INVALID_PLATFORM)
250 return NULL;
251
252 mtx_lock(_eglGlobal.Mutex);
253
254 /* search the display list first */
255 for (disp = _eglGlobal.DisplayList; disp; disp = disp->Next) {
256 if (disp->Platform == plat && disp->PlatformDisplay == plat_dpy &&
257 _eglSameAttribs(disp->Options.Attribs, attrib_list))
258 break;
259 }
260
261 /* create a new display */
262 if (!disp) {
263 disp = calloc(1, sizeof(_EGLDisplay));
264 if (disp) {
265 mtx_init(&disp->Mutex, mtx_plain);
266 disp->Platform = plat;
267 disp->PlatformDisplay = plat_dpy;
268 num_attribs = _eglNumAttribs(attrib_list);
269 if (num_attribs) {
270 disp->Options.Attribs = calloc(num_attribs, sizeof(EGLAttrib));
271 if (!disp->Options.Attribs) {
272 free(disp);
273 disp = NULL;
274 goto out;
275 }
276 memcpy(disp->Options.Attribs, attrib_list,
277 num_attribs * sizeof(EGLAttrib));
278 }
279 /* add to the display list */
280 disp->Next = _eglGlobal.DisplayList;
281 _eglGlobal.DisplayList = disp;
282 }
283 }
284
285 out:
286 mtx_unlock(_eglGlobal.Mutex);
287
288 return disp;
289 }
290
291
292 /**
293 * Destroy the contexts and surfaces that are linked to the display.
294 */
295 void
296 _eglReleaseDisplayResources(_EGLDisplay *display)
297 {
298 _EGLResource *list;
299 const _EGLDriver *drv = display->Driver;
300
301 list = display->ResourceLists[_EGL_RESOURCE_CONTEXT];
302 while (list) {
303 _EGLContext *ctx = (_EGLContext *) list;
304 list = list->Next;
305
306 _eglUnlinkContext(ctx);
307 drv->DestroyContext(drv, display, ctx);
308 }
309 assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
310
311 list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
312 while (list) {
313 _EGLSurface *surf = (_EGLSurface *) list;
314 list = list->Next;
315
316 _eglUnlinkSurface(surf);
317 drv->DestroySurface(drv, display, surf);
318 }
319 assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
320
321 list = display->ResourceLists[_EGL_RESOURCE_IMAGE];
322 while (list) {
323 _EGLImage *image = (_EGLImage *) list;
324 list = list->Next;
325
326 _eglUnlinkImage(image);
327 drv->DestroyImageKHR(drv, display, image);
328 }
329 assert(!display->ResourceLists[_EGL_RESOURCE_IMAGE]);
330
331 list = display->ResourceLists[_EGL_RESOURCE_SYNC];
332 while (list) {
333 _EGLSync *sync = (_EGLSync *) list;
334 list = list->Next;
335
336 _eglUnlinkSync(sync);
337 drv->DestroySyncKHR(drv, display, sync);
338 }
339 assert(!display->ResourceLists[_EGL_RESOURCE_SYNC]);
340 }
341
342
343 /**
344 * Free all the data hanging of an _EGLDisplay object, but not
345 * the object itself.
346 */
347 void
348 _eglCleanupDisplay(_EGLDisplay *disp)
349 {
350 if (disp->Configs) {
351 _eglDestroyArray(disp->Configs, free);
352 disp->Configs = NULL;
353 }
354
355 /* XXX incomplete */
356 }
357
358
359 /**
360 * Return EGL_TRUE if the given handle is a valid handle to a display.
361 */
362 EGLBoolean
363 _eglCheckDisplayHandle(EGLDisplay dpy)
364 {
365 _EGLDisplay *cur;
366
367 mtx_lock(_eglGlobal.Mutex);
368 cur = _eglGlobal.DisplayList;
369 while (cur) {
370 if (cur == (_EGLDisplay *) dpy)
371 break;
372 cur = cur->Next;
373 }
374 mtx_unlock(_eglGlobal.Mutex);
375 return (cur != NULL);
376 }
377
378
379 /**
380 * Return EGL_TRUE if the given resource is valid. That is, the display does
381 * own the resource.
382 */
383 EGLBoolean
384 _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *disp)
385 {
386 _EGLResource *list = disp->ResourceLists[type];
387
388 if (!res)
389 return EGL_FALSE;
390
391 while (list) {
392 if (res == (void *) list) {
393 assert(list->Display == disp);
394 break;
395 }
396 list = list->Next;
397 }
398
399 return (list != NULL);
400 }
401
402
403 /**
404 * Initialize a display resource. The size of the subclass object is
405 * specified.
406 *
407 * This is supposed to be called from the initializers of subclasses, such as
408 * _eglInitContext or _eglInitSurface.
409 */
410 void
411 _eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *disp)
412 {
413 memset(res, 0, size);
414 res->Display = disp;
415 res->RefCount = 1;
416 }
417
418
419 /**
420 * Increment reference count for the resource.
421 */
422 void
423 _eglGetResource(_EGLResource *res)
424 {
425 assert(res && res->RefCount > 0);
426 /* hopefully a resource is always manipulated with its display locked */
427 res->RefCount++;
428 }
429
430
431 /**
432 * Decrement reference count for the resource.
433 */
434 EGLBoolean
435 _eglPutResource(_EGLResource *res)
436 {
437 assert(res && res->RefCount > 0);
438 res->RefCount--;
439 return (!res->RefCount);
440 }
441
442
443 /**
444 * Link a resource to its display.
445 */
446 void
447 _eglLinkResource(_EGLResource *res, _EGLResourceType type)
448 {
449 assert(res->Display);
450
451 res->IsLinked = EGL_TRUE;
452 res->Next = res->Display->ResourceLists[type];
453 res->Display->ResourceLists[type] = res;
454 _eglGetResource(res);
455 }
456
457
458 /**
459 * Unlink a linked resource from its display.
460 */
461 void
462 _eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
463 {
464 _EGLResource *prev;
465
466 prev = res->Display->ResourceLists[type];
467 if (prev != res) {
468 while (prev) {
469 if (prev->Next == res)
470 break;
471 prev = prev->Next;
472 }
473 assert(prev);
474 prev->Next = res->Next;
475 }
476 else {
477 res->Display->ResourceLists[type] = res->Next;
478 }
479
480 res->Next = NULL;
481 res->IsLinked = EGL_FALSE;
482 _eglPutResource(res);
483
484 /* We always unlink before destroy. The driver still owns a reference */
485 assert(res->RefCount);
486 }
487
488 #ifdef HAVE_X11_PLATFORM
489 _EGLDisplay*
490 _eglGetX11Display(Display *native_display,
491 const EGLAttrib *attrib_list)
492 {
493 /* EGL_EXT_platform_x11 recognizes exactly one attribute,
494 * EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
495 */
496 if (attrib_list != NULL) {
497 for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
498 if (attrib_list[i] != EGL_PLATFORM_X11_SCREEN_EXT) {
499 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
500 return NULL;
501 }
502 }
503 }
504 return _eglFindDisplay(_EGL_PLATFORM_X11, native_display, attrib_list);
505 }
506 #endif /* HAVE_X11_PLATFORM */
507
508 #ifdef HAVE_DRM_PLATFORM
509 _EGLDisplay*
510 _eglGetGbmDisplay(struct gbm_device *native_display,
511 const EGLAttrib *attrib_list)
512 {
513 /* EGL_MESA_platform_gbm recognizes no attributes. */
514 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
515 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
516 return NULL;
517 }
518
519 return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display, attrib_list);
520 }
521 #endif /* HAVE_DRM_PLATFORM */
522
523 #ifdef HAVE_WAYLAND_PLATFORM
524 _EGLDisplay*
525 _eglGetWaylandDisplay(struct wl_display *native_display,
526 const EGLAttrib *attrib_list)
527 {
528 /* EGL_EXT_platform_wayland recognizes no attributes. */
529 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
530 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
531 return NULL;
532 }
533
534 return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display, attrib_list);
535 }
536 #endif /* HAVE_WAYLAND_PLATFORM */
537
538 _EGLDisplay*
539 _eglGetSurfacelessDisplay(void *native_display,
540 const EGLAttrib *attrib_list)
541 {
542 /* This platform has no native display. */
543 if (native_display != NULL) {
544 _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
545 return NULL;
546 }
547
548 /* This platform recognizes no display attributes. */
549 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
550 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
551 return NULL;
552 }
553
554 return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display,
555 attrib_list);
556 }
557
558 #ifdef HAVE_ANDROID_PLATFORM
559 _EGLDisplay*
560 _eglGetAndroidDisplay(void *native_display,
561 const EGLAttrib *attrib_list)
562 {
563
564 /* This platform recognizes no display attributes. */
565 if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
566 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
567 return NULL;
568 }
569
570 return _eglFindDisplay(_EGL_PLATFORM_ANDROID, native_display,
571 attrib_list);
572 }
573 #endif /* HAVE_ANDROID_PLATFORM */
574
575 _EGLDisplay*
576 _eglGetDeviceDisplay(void *native_display,
577 const EGLAttrib *attrib_list)
578 {
579 _EGLDevice *dev;
580 _EGLDisplay *display;
581 int fd = -1;
582
583 dev = _eglLookupDevice(native_display);
584 if (!dev) {
585 _eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
586 return NULL;
587 }
588
589 if (attrib_list) {
590 for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
591 EGLAttrib attrib = attrib_list[i];
592 EGLAttrib value = attrib_list[i + 1];
593
594 /* EGL_EXT_platform_device does not recognize any attributes,
595 * EGL_EXT_device_drm adds the optional EGL_DRM_MASTER_FD_EXT.
596 */
597
598 if (!_eglDeviceSupports(dev, _EGL_DEVICE_DRM) ||
599 attrib != EGL_DRM_MASTER_FD_EXT) {
600 _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
601 return NULL;
602 }
603
604 fd = (int) value;
605 }
606 }
607
608 display = _eglFindDisplay(_EGL_PLATFORM_DEVICE, native_display, attrib_list);
609 if (!display) {
610 _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
611 return NULL;
612 }
613
614 /* If the fd is explicitly provided and we did not dup() it yet, do so.
615 * The spec mandates that we do so, since we'll need it past the
616 * eglGetPlatformDispay call.
617 *
618 * The new fd is guaranteed to be 3 or greater.
619 */
620 if (fd != -1 && display->Options.fd == 0) {
621 display->Options.fd = os_dupfd_cloexec(fd);
622 if (display->Options.fd == -1) {
623 /* Do not (really) need to teardown the display */
624 _eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
625 return NULL;
626 }
627 }
628
629 return display;
630 }