1 /************************************************************************** 2 * 3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * Copyright 2009-2010 Chia-I Wu <olvaffe (at) 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 "eglcontext.h" 39 #include "eglsurface.h" 40 #include "egldisplay.h" 41 #include "egldriver.h" 42 #include "eglglobals.h" 43 #include "eglmutex.h" 44 #include "egllog.h" 45 46 /* Includes for _eglNativePlatformDetectNativeDisplay */ 47 #ifdef HAVE_MINCORE 48 #include <unistd.h> 49 #include <sys/mman.h> 50 #endif 51 #ifdef HAVE_WAYLAND_PLATFORM 52 #include <wayland-client.h> 53 #endif 54 #ifdef HAVE_DRM_PLATFORM 55 #include <gbm.h> 56 #endif 57 #ifdef HAVE_FBDEV_PLATFORM 58 #include <stdint.h> 59 #include <sys/types.h> 60 #include <sys/stat.h> 61 #endif 62 63 64 /** 65 * Map --with-egl-platforms names to platform types. 66 */ 67 static const struct { 68 _EGLPlatformType platform; 69 const char *name; 70 } egl_platforms[_EGL_NUM_PLATFORMS] = { 71 { _EGL_PLATFORM_WINDOWS, "gdi" }, 72 { _EGL_PLATFORM_X11, "x11" }, 73 { _EGL_PLATFORM_WAYLAND, "wayland" }, 74 { _EGL_PLATFORM_DRM, "drm" }, 75 { _EGL_PLATFORM_FBDEV, "fbdev" }, 76 { _EGL_PLATFORM_NULL, "null" }, 77 { _EGL_PLATFORM_ANDROID, "android" } 78 }; 79 80 81 /** 82 * Return the native platform by parsing EGL_PLATFORM. 83 */ 84 static _EGLPlatformType 85 _eglGetNativePlatformFromEnv(void) 86 { 87 _EGLPlatformType plat = _EGL_INVALID_PLATFORM; 88 const char *plat_name; 89 EGLint i; 90 91 plat_name = getenv("EGL_PLATFORM"); 92 /* try deprecated env variable */ 93 if (!plat_name || !plat_name[0]) 94 plat_name = getenv("EGL_DISPLAY"); 95 if (!plat_name || !plat_name[0]) 96 return _EGL_INVALID_PLATFORM; 97 98 for (i = 0; i < _EGL_NUM_PLATFORMS; i++) { 99 if (strcmp(egl_platforms[i].name, plat_name) == 0) { 100 plat = egl_platforms[i].platform; 101 break; 102 } 103 } 104 105 return plat; 106 } 107 108 109 /** 110 * Perform validity checks on a generic pointer. 111 */ 112 static EGLBoolean 113 _eglPointerIsDereferencable(void *p) 114 { 115 #ifdef HAVE_MINCORE 116 uintptr_t addr = (uintptr_t) p; 117 unsigned char valid = 0; 118 const long page_size = getpagesize(); 119 120 if (p == NULL) 121 return EGL_FALSE; 122 123 /* align addr to page_size */ 124 addr &= ~(page_size - 1); 125 126 if (mincore((void *) addr, page_size, &valid) < 0) { 127 _eglLog(_EGL_DEBUG, "mincore failed: %m"); 128 return EGL_FALSE; 129 } 130 131 return (valid & 0x01) == 0x01; 132 #else 133 return p != NULL; 134 #endif 135 } 136 137 138 /** 139 * Try detecting native platform with the help of native display characteristcs. 140 */ 141 static _EGLPlatformType 142 _eglNativePlatformDetectNativeDisplay(EGLNativeDisplayType nativeDisplay) 143 { 144 #ifdef HAVE_FBDEV_PLATFORM 145 struct stat buf; 146 #endif 147 148 if (nativeDisplay == EGL_DEFAULT_DISPLAY) 149 return _EGL_INVALID_PLATFORM; 150 151 #ifdef HAVE_FBDEV_PLATFORM 152 /* fbdev is the only platform that can be a file descriptor. */ 153 if (fstat((intptr_t) nativeDisplay, &buf) == 0 && S_ISCHR(buf.st_mode)) 154 return _EGL_PLATFORM_FBDEV; 155 #endif 156 157 if (_eglPointerIsDereferencable(nativeDisplay)) { 158 void *first_pointer = *(void **) nativeDisplay; 159 160 (void) first_pointer; /* silence unused var warning */ 161 162 #ifdef HAVE_WAYLAND_PLATFORM 163 /* wl_display is a wl_proxy, which is a wl_object. 164 * wl_object's first element points to the interfacetype. */ 165 if (first_pointer == &wl_display_interface) 166 return _EGL_PLATFORM_WAYLAND; 167 #endif 168 169 #ifdef HAVE_DRM_PLATFORM 170 /* gbm has a pointer to its constructor as first element. */ 171 if (first_pointer == gbm_create_device) 172 return _EGL_PLATFORM_DRM; 173 #endif 174 175 #ifdef HAVE_X11_PLATFORM 176 /* If not matched to any other platform, fallback to x11. */ 177 return _EGL_PLATFORM_X11; 178 #endif 179 } 180 181 return _EGL_INVALID_PLATFORM; 182 } 183 184 185 /** 186 * Return the native platform. It is the platform of the EGL native types. 187 */ 188 _EGLPlatformType 189 _eglGetNativePlatform(EGLNativeDisplayType nativeDisplay) 190 { 191 static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM; 192 char *detection_method = NULL; 193 194 if (native_platform == _EGL_INVALID_PLATFORM) { 195 native_platform = _eglGetNativePlatformFromEnv(); 196 detection_method = "environment overwrite"; 197 if (native_platform == _EGL_INVALID_PLATFORM) { 198 native_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay); 199 detection_method = "autodetected"; 200 if (native_platform == _EGL_INVALID_PLATFORM) { 201 native_platform = _EGL_NATIVE_PLATFORM; 202 detection_method = "build-time configuration"; 203 } 204 } 205 } 206 207 if (detection_method != NULL) 208 _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)", 209 egl_platforms[native_platform].name, detection_method); 210 211 return native_platform; 212 } 213 214 215 /** 216 * Finish display management. 217 */ 218 void 219 _eglFiniDisplay(void) 220 { 221 _EGLDisplay *dpyList, *dpy; 222 223 /* atexit function is called with global mutex locked */ 224 dpyList = _eglGlobal.DisplayList; 225 while (dpyList) { 226 EGLint i; 227 228 /* pop list head */ 229 dpy = dpyList; 230 dpyList = dpyList->Next; 231 232 for (i = 0; i < _EGL_NUM_RESOURCES; i++) { 233 if (dpy->ResourceLists[i]) { 234 _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy); 235 break; 236 } 237 } 238 239 free(dpy); 240 } 241 _eglGlobal.DisplayList = NULL; 242 } 243 244 245 /** 246 * Find the display corresponding to the specified native display, or create a 247 * new one. 248 */ 249 _EGLDisplay * 250 _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy) 251 { 252 _EGLDisplay *dpy; 253 254 if (plat == _EGL_INVALID_PLATFORM) 255 return NULL; 256 257 _eglLockMutex(_eglGlobal.Mutex); 258 259 /* search the display list first */ 260 dpy = _eglGlobal.DisplayList; 261 while (dpy) { 262 if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy) 263 break; 264 dpy = dpy->Next; 265 } 266 267 /* create a new display */ 268 if (!dpy) { 269 dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay)); 270 if (dpy) { 271 _eglInitMutex(&dpy->Mutex); 272 dpy->Platform = plat; 273 dpy->PlatformDisplay = plat_dpy; 274 275 /* add to the display list */ 276 dpy->Next = _eglGlobal.DisplayList; 277 _eglGlobal.DisplayList = dpy; 278 } 279 } 280 281 _eglUnlockMutex(_eglGlobal.Mutex); 282 283 return dpy; 284 } 285 286 287 /** 288 * Destroy the contexts and surfaces that are linked to the display. 289 */ 290 void 291 _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display) 292 { 293 _EGLResource *list; 294 295 list = display->ResourceLists[_EGL_RESOURCE_CONTEXT]; 296 while (list) { 297 _EGLContext *ctx = (_EGLContext *) list; 298 list = list->Next; 299 300 _eglUnlinkContext(ctx); 301 drv->API.DestroyContext(drv, display, ctx); 302 } 303 assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]); 304 305 list = display->ResourceLists[_EGL_RESOURCE_SURFACE]; 306 while (list) { 307 _EGLSurface *surf = (_EGLSurface *) list; 308 list = list->Next; 309 310 _eglUnlinkSurface(surf); 311 drv->API.DestroySurface(drv, display, surf); 312 } 313 assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]); 314 } 315 316 317 /** 318 * Free all the data hanging of an _EGLDisplay object, but not 319 * the object itself. 320 */ 321 void 322 _eglCleanupDisplay(_EGLDisplay *disp) 323 { 324 if (disp->Configs) { 325 _eglDestroyArray(disp->Configs, free); 326 disp->Configs = NULL; 327 } 328 329 /* XXX incomplete */ 330 } 331 332 333 /** 334 * Return EGL_TRUE if the given handle is a valid handle to a display. 335 */ 336 EGLBoolean 337 _eglCheckDisplayHandle(EGLDisplay dpy) 338 { 339 _EGLDisplay *cur; 340 341 _eglLockMutex(_eglGlobal.Mutex); 342 cur = _eglGlobal.DisplayList; 343 while (cur) { 344 if (cur == (_EGLDisplay *) dpy) 345 break; 346 cur = cur->Next; 347 } 348 _eglUnlockMutex(_eglGlobal.Mutex); 349 return (cur != NULL); 350 } 351 352 353 /** 354 * Return EGL_TRUE if the given resource is valid. That is, the display does 355 * own the resource. 356 */ 357 EGLBoolean 358 _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy) 359 { 360 _EGLResource *list = dpy->ResourceLists[type]; 361 362 if (!res) 363 return EGL_FALSE; 364 365 while (list) { 366 if (res == (void *) list) { 367 assert(list->Display == dpy); 368 break; 369 } 370 list = list->Next; 371 } 372 373 return (list != NULL); 374 } 375 376 377 /** 378 * Initialize a display resource. 379 */ 380 void 381 _eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy) 382 { 383 memset(res, 0, size); 384 res->Display = dpy; 385 res->RefCount = 1; 386 } 387 388 389 /** 390 * Increment reference count for the resource. 391 */ 392 void 393 _eglGetResource(_EGLResource *res) 394 { 395 assert(res && res->RefCount > 0); 396 /* hopefully a resource is always manipulated with its display locked */ 397 res->RefCount++; 398 } 399 400 401 /** 402 * Decrement reference count for the resource. 403 */ 404 EGLBoolean 405 _eglPutResource(_EGLResource *res) 406 { 407 assert(res && res->RefCount > 0); 408 res->RefCount--; 409 return (!res->RefCount); 410 } 411 412 413 /** 414 * Link a resource to its display. 415 */ 416 void 417 _eglLinkResource(_EGLResource *res, _EGLResourceType type) 418 { 419 assert(res->Display); 420 421 res->IsLinked = EGL_TRUE; 422 res->Next = res->Display->ResourceLists[type]; 423 res->Display->ResourceLists[type] = res; 424 _eglGetResource(res); 425 } 426 427 428 /** 429 * Unlink a linked resource from its display. 430 */ 431 void 432 _eglUnlinkResource(_EGLResource *res, _EGLResourceType type) 433 { 434 _EGLResource *prev; 435 436 prev = res->Display->ResourceLists[type]; 437 if (prev != res) { 438 while (prev) { 439 if (prev->Next == res) 440 break; 441 prev = prev->Next; 442 } 443 assert(prev); 444 prev->Next = res->Next; 445 } 446 else { 447 res->Display->ResourceLists[type] = res->Next; 448 } 449 450 res->Next = NULL; 451 res->IsLinked = EGL_FALSE; 452 _eglPutResource(res); 453 454 /* We always unlink before destroy. The driver still owns a reference */ 455 assert(res->RefCount); 456 } 457
