1 /**************************************************************************
2  *
3  * Copyright (C) 2014 Red Hat Inc.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included
13  * in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21  * OTHER DEALINGS IN THE SOFTWARE.
22  *
23  **************************************************************************/
24 /* create our own EGL offscreen rendering context via gbm and rendernodes */
25 
26 
27 /* if we are using EGL and rendernodes then we talk via file descriptors to the remote
28    node */
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32 
33 #define EGL_EGLEXT_PROTOTYPES
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <stdbool.h>
37 #include <epoxy/egl.h>
38 #include <xf86drm.h>
39 
40 #include "util/u_memory.h"
41 
42 #include "virglrenderer.h"
43 #include "virgl_egl.h"
44 #include "virgl_hw.h"
45 #include "virgl_gbm.h"
46 #include "vrend_util.h"
47 
48 #define EGL_KHR_SURFACELESS_CONTEXT            BIT(0)
49 #define EGL_KHR_CREATE_CONTEXT                 BIT(1)
50 #define EGL_MESA_DRM_IMAGE                     BIT(2)
51 #define EGL_MESA_IMAGE_DMA_BUF_EXPORT          BIT(3)
52 #define EGL_MESA_DMA_BUF_IMAGE_IMPORT          BIT(4)
53 #define EGL_KHR_GL_COLORSPACE                  BIT(5)
54 #define EGL_EXT_IMAGE_DMA_BUF_IMPORT           BIT(6)
55 #define EGL_EXT_IMAGE_DMA_BUF_IMPORT_MODIFIERS BIT(7)
56 #define EGL_KHR_FENCE_SYNC                     BIT(8)
57 
58 static const struct {
59    uint32_t bit;
60    const char *string;
61 } extensions_list[] = {
62    { EGL_KHR_SURFACELESS_CONTEXT, "EGL_KHR_surfaceless_context" },
63    { EGL_KHR_CREATE_CONTEXT, "EGL_KHR_create_context" },
64    { EGL_MESA_DRM_IMAGE, "EGL_MESA_drm_image" },
65    { EGL_MESA_IMAGE_DMA_BUF_EXPORT, "EGL_MESA_image_dma_buf_export" },
66    { EGL_KHR_GL_COLORSPACE, "EGL_KHR_gl_colorspace" },
67    { EGL_EXT_IMAGE_DMA_BUF_IMPORT, "EGL_EXT_image_dma_buf_import" },
68    { EGL_EXT_IMAGE_DMA_BUF_IMPORT_MODIFIERS, "EGL_EXT_image_dma_buf_import_modifiers" },
69    { EGL_KHR_FENCE_SYNC, "EGL_KHR_fence_sync"}
70 };
71 
72 struct virgl_egl {
73    struct virgl_gbm *gbm;
74    EGLDisplay egl_display;
75    EGLConfig egl_conf;
76    EGLContext egl_ctx;
77    uint32_t extension_bits;
78    bool need_fence_and_wait_external;
79 };
80 
virgl_egl_has_extension_in_string(const char * haystack,const char * needle)81 static bool virgl_egl_has_extension_in_string(const char *haystack, const char *needle)
82 {
83    const unsigned needle_len = strlen(needle);
84 
85    if (needle_len == 0)
86       return false;
87 
88    while (true) {
89       const char *const s = strstr(haystack, needle);
90 
91       if (s == NULL)
92          return false;
93 
94       if (s[needle_len] == ' ' || s[needle_len] == '\0') {
95          return true;
96       }
97 
98       /* strstr found an extension whose name begins with
99        * needle, but whose name is not equal to needle.
100        * Restart the search at s + needle_len so that we
101        * don't just find the same extension again and go
102        * into an infinite loop.
103        */
104       haystack = s + needle_len;
105    }
106 
107    return false;
108 }
109 
virgl_egl_init_extensions(struct virgl_egl * egl,const char * extensions)110 static int virgl_egl_init_extensions(struct virgl_egl *egl, const char *extensions)
111 {
112    for (uint32_t i = 0; i < ARRAY_SIZE(extensions_list); i++) {
113       if (virgl_egl_has_extension_in_string(extensions, extensions_list[i].string))
114          egl->extension_bits |= extensions_list[i].bit;
115    }
116 
117    if (!has_bits(egl->extension_bits, EGL_KHR_SURFACELESS_CONTEXT | EGL_KHR_CREATE_CONTEXT)) {
118       vrend_printf( "Missing EGL_KHR_surfaceless_context or EGL_KHR_create_context\n");
119       return -1;
120    }
121 
122    return 0;
123 }
124 
virgl_egl_init(struct virgl_gbm * gbm,bool surfaceless,bool gles)125 struct virgl_egl *virgl_egl_init(struct virgl_gbm *gbm, bool surfaceless, bool gles)
126 {
127    static EGLint conf_att[] = {
128       EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
129       EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
130       EGL_RED_SIZE, 1,
131       EGL_GREEN_SIZE, 1,
132       EGL_BLUE_SIZE, 1,
133       EGL_ALPHA_SIZE, 0,
134       EGL_NONE,
135    };
136    static const EGLint ctx_att[] = {
137       EGL_CONTEXT_CLIENT_VERSION, 2,
138       EGL_NONE
139    };
140    EGLBoolean success;
141    EGLenum api;
142    EGLint major, minor, num_configs;
143    const char *extensions;
144    struct virgl_egl *egl;
145 
146    egl = calloc(1, sizeof(struct virgl_egl));
147    if (!egl)
148       return NULL;
149 
150    if (gles)
151       conf_att[3] = EGL_OPENGL_ES2_BIT;
152 
153    if (surfaceless)
154       conf_att[1] = EGL_PBUFFER_BIT;
155    else if (!gbm)
156       goto fail;
157 
158    egl->gbm = gbm;
159    const char *client_extensions = eglQueryString (NULL, EGL_EXTENSIONS);
160 
161    if (client_extensions && strstr(client_extensions, "EGL_KHR_platform_base")) {
162       PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display =
163          (PFNEGLGETPLATFORMDISPLAYEXTPROC) eglGetProcAddress ("eglGetPlatformDisplay");
164 
165       if (!get_platform_display)
166         goto fail;
167 
168       if (surfaceless) {
169          egl->egl_display = get_platform_display (EGL_PLATFORM_SURFACELESS_MESA,
170                                                   EGL_DEFAULT_DISPLAY, NULL);
171       } else
172          egl->egl_display = get_platform_display (EGL_PLATFORM_GBM_KHR,
173                                                   (EGLNativeDisplayType)egl->gbm->device, NULL);
174    } else if (client_extensions && strstr(client_extensions, "EGL_EXT_platform_base")) {
175       PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display =
176          (PFNEGLGETPLATFORMDISPLAYEXTPROC) eglGetProcAddress ("eglGetPlatformDisplayEXT");
177 
178       if (!get_platform_display)
179         goto fail;
180 
181       if (surfaceless) {
182          egl->egl_display = get_platform_display (EGL_PLATFORM_SURFACELESS_MESA,
183                                                   EGL_DEFAULT_DISPLAY, NULL);
184       } else
185          egl->egl_display = get_platform_display (EGL_PLATFORM_GBM_KHR,
186                                                  (EGLNativeDisplayType)egl->gbm->device, NULL);
187    } else {
188       egl->egl_display = eglGetDisplay((EGLNativeDisplayType)egl->gbm->device);
189    }
190 
191    if (!egl->egl_display) {
192       /*
193        * Don't fallback to the default display if the fd provided by (*get_drm_fd)
194        * can't be used.
195        */
196       if (egl->gbm && egl->gbm->fd < 0)
197          goto fail;
198 
199       egl->egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
200       if (!egl->egl_display)
201          goto fail;
202    }
203 
204    success = eglInitialize(egl->egl_display, &major, &minor);
205    if (!success)
206       goto fail;
207 
208    extensions = eglQueryString(egl->egl_display, EGL_EXTENSIONS);
209 #ifdef VIRGL_EGL_DEBUG
210    vrend_printf( "EGL major/minor: %d.%d\n", major, minor);
211    vrend_printf( "EGL version: %s\n",
212            eglQueryString(egl->egl_display, EGL_VERSION));
213    vrend_printf( "EGL vendor: %s\n",
214            eglQueryString(egl->egl_display, EGL_VENDOR));
215    vrend_printf( "EGL extensions: %s\n", extensions);
216 #endif
217 
218    if (virgl_egl_init_extensions(egl, extensions))
219       goto fail;
220 
221    // ARM Mali platforms need explicit synchronization prior to mapping.
222    if (!strcmp(eglQueryString(egl->egl_display, EGL_VENDOR), "ARM"))
223       egl->need_fence_and_wait_external = true;
224 
225    if (gles)
226       api = EGL_OPENGL_ES_API;
227    else
228       api = EGL_OPENGL_API;
229    success = eglBindAPI(api);
230    if (!success)
231       goto fail;
232 
233    success = eglChooseConfig(egl->egl_display, conf_att, &egl->egl_conf,
234                              1, &num_configs);
235    if (!success || num_configs != 1)
236       goto fail;
237 
238    egl->egl_ctx = eglCreateContext(egl->egl_display, egl->egl_conf, EGL_NO_CONTEXT,
239                                    ctx_att);
240    if (!egl->egl_ctx)
241       goto fail;
242 
243    eglMakeCurrent(egl->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
244                   egl->egl_ctx);
245    return egl;
246 
247  fail:
248    free(egl);
249    return NULL;
250 }
251 
virgl_egl_destroy(struct virgl_egl * egl)252 void virgl_egl_destroy(struct virgl_egl *egl)
253 {
254    eglMakeCurrent(egl->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
255                   EGL_NO_CONTEXT);
256    eglDestroyContext(egl->egl_display, egl->egl_ctx);
257    eglTerminate(egl->egl_display);
258    free(egl);
259 }
260 
virgl_egl_create_context(struct virgl_egl * egl,struct virgl_gl_ctx_param * vparams)261 virgl_renderer_gl_context virgl_egl_create_context(struct virgl_egl *egl, struct virgl_gl_ctx_param *vparams)
262 {
263    EGLContext egl_ctx;
264    EGLint ctx_att[] = {
265       EGL_CONTEXT_CLIENT_VERSION, vparams->major_ver,
266       EGL_CONTEXT_MINOR_VERSION_KHR, vparams->minor_ver,
267       EGL_NONE
268    };
269    egl_ctx = eglCreateContext(egl->egl_display,
270                              egl->egl_conf,
271                              vparams->shared ? eglGetCurrentContext() : EGL_NO_CONTEXT,
272                              ctx_att);
273    return (virgl_renderer_gl_context)egl_ctx;
274 }
275 
virgl_egl_destroy_context(struct virgl_egl * egl,virgl_renderer_gl_context virglctx)276 void virgl_egl_destroy_context(struct virgl_egl *egl, virgl_renderer_gl_context virglctx)
277 {
278    EGLContext egl_ctx = (EGLContext)virglctx;
279    eglDestroyContext(egl->egl_display, egl_ctx);
280 }
281 
virgl_egl_make_context_current(struct virgl_egl * egl,virgl_renderer_gl_context virglctx)282 int virgl_egl_make_context_current(struct virgl_egl *egl, virgl_renderer_gl_context virglctx)
283 {
284    EGLContext egl_ctx = (EGLContext)virglctx;
285 
286    return eglMakeCurrent(egl->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
287                          egl_ctx);
288 }
289 
virgl_egl_get_current_context(UNUSED struct virgl_egl * egl)290 virgl_renderer_gl_context virgl_egl_get_current_context(UNUSED struct virgl_egl *egl)
291 {
292    EGLContext egl_ctx = eglGetCurrentContext();
293    return (virgl_renderer_gl_context)egl_ctx;
294 }
295 
virgl_egl_get_fourcc_for_texture(struct virgl_egl * egl,uint32_t tex_id,uint32_t format,int * fourcc)296 int virgl_egl_get_fourcc_for_texture(struct virgl_egl *egl, uint32_t tex_id, uint32_t format, int *fourcc)
297 {
298    int ret = EINVAL;
299    uint32_t gbm_format = 0;
300 
301    EGLImageKHR image;
302    EGLBoolean success;
303 
304    if (!has_bit(egl->extension_bits, EGL_MESA_IMAGE_DMA_BUF_EXPORT)) {
305       ret = 0;
306       goto fallback;
307    }
308 
309    image = eglCreateImageKHR(egl->egl_display, eglGetCurrentContext(), EGL_GL_TEXTURE_2D_KHR,
310                             (EGLClientBuffer)(unsigned long)tex_id, NULL);
311 
312    if (!image)
313       return EINVAL;
314 
315    success = eglExportDMABUFImageQueryMESA(egl->egl_display, image, fourcc, NULL, NULL);
316    if (!success)
317       goto out_destroy;
318    ret = 0;
319  out_destroy:
320    eglDestroyImageKHR(egl->egl_display, image);
321    return ret;
322 
323  fallback:
324    ret = virgl_gbm_convert_format(&format, &gbm_format);
325    *fourcc = (int)gbm_format;
326    return ret;
327 }
328 
virgl_egl_get_fd_for_texture2(struct virgl_egl * egl,uint32_t tex_id,int * fd,int * stride,int * offset)329 int virgl_egl_get_fd_for_texture2(struct virgl_egl *egl, uint32_t tex_id, int *fd,
330                                   int *stride, int *offset)
331 {
332    int ret = EINVAL;
333    EGLImageKHR image = eglCreateImageKHR(egl->egl_display, eglGetCurrentContext(),
334                                          EGL_GL_TEXTURE_2D_KHR,
335                                          (EGLClientBuffer)(unsigned long)tex_id, NULL);
336    if (!image)
337       return EINVAL;
338    if (!has_bit(egl->extension_bits, EGL_MESA_IMAGE_DMA_BUF_EXPORT))
339       goto out_destroy;
340 
341    if (!eglExportDMABUFImageMESA(egl->egl_display, image, fd,
342                                  stride, offset))
343       goto out_destroy;
344 
345    ret = 0;
346 
347 out_destroy:
348    eglDestroyImageKHR(egl->egl_display, image);
349    return ret;
350 }
351 
virgl_egl_get_fd_for_texture(struct virgl_egl * egl,uint32_t tex_id,int * fd)352 int virgl_egl_get_fd_for_texture(struct virgl_egl *egl, uint32_t tex_id, int *fd)
353 {
354    EGLImageKHR image;
355    EGLint stride;
356    EGLint offset;
357    EGLBoolean success;
358    int ret;
359    image = eglCreateImageKHR(egl->egl_display, eglGetCurrentContext(), EGL_GL_TEXTURE_2D_KHR,
360                             (EGLClientBuffer)(unsigned long)tex_id, NULL);
361 
362    if (!image)
363       return EINVAL;
364 
365    ret = EINVAL;
366    if (has_bit(egl->extension_bits, EGL_MESA_IMAGE_DMA_BUF_EXPORT)) {
367       success = eglExportDMABUFImageMESA(egl->egl_display, image, fd, &stride,
368                                          &offset);
369       if (!success)
370          goto out_destroy;
371    } else if (has_bit(egl->extension_bits, EGL_MESA_DRM_IMAGE)) {
372       EGLint handle;
373       success = eglExportDRMImageMESA(egl->egl_display, image, NULL, &handle,
374                                       &stride);
375 
376       if (!success)
377          goto out_destroy;
378 
379       if (!egl->gbm)
380          goto out_destroy;
381 
382       ret = virgl_gbm_export_fd(egl->gbm->device, handle, fd);
383       if (ret < 0)
384          goto out_destroy;
385    } else {
386       goto out_destroy;
387    }
388 
389    ret = 0;
390  out_destroy:
391    eglDestroyImageKHR(egl->egl_display, image);
392    return ret;
393 }
394 
virgl_has_egl_khr_gl_colorspace(struct virgl_egl * egl)395 bool virgl_has_egl_khr_gl_colorspace(struct virgl_egl *egl)
396 {
397    return has_bit(egl->extension_bits, EGL_KHR_GL_COLORSPACE);
398 }
399 
400 #ifdef ENABLE_GBM_ALLOCATION
virgl_egl_image_from_dmabuf(struct virgl_egl * egl,struct gbm_bo * bo)401 void *virgl_egl_image_from_dmabuf(struct virgl_egl *egl, struct gbm_bo *bo)
402 {
403    int ret;
404    EGLImageKHR image;
405    int fds[VIRGL_GBM_MAX_PLANES] = {-1, -1, -1, -1};
406    int num_planes = gbm_bo_get_plane_count(bo);
407    // When the bo has 3 planes with modifier support, it requires 37 components.
408    EGLint khr_image_attrs[37] = {
409       EGL_WIDTH,
410       gbm_bo_get_width(bo),
411       EGL_HEIGHT,
412       gbm_bo_get_height(bo),
413       EGL_LINUX_DRM_FOURCC_EXT,
414       (int)gbm_bo_get_format(bo),
415       EGL_NONE,
416    };
417 
418    if (num_planes < 0 || num_planes > VIRGL_GBM_MAX_PLANES)
419       return (void *)EGL_NO_IMAGE_KHR;
420 
421    for (int plane = 0; plane < num_planes; plane++) {
422       uint32_t handle = gbm_bo_get_handle_for_plane(bo, plane).u32;
423       ret = virgl_gbm_export_fd(egl->gbm->device, handle, &fds[plane]);
424       if (ret < 0) {
425          vrend_printf( "failed to export plane handle\n");
426          image = (void *)EGL_NO_IMAGE_KHR;
427          goto out_close;
428       }
429    }
430 
431    size_t attrs_index = 6;
432    for (int plane = 0; plane < num_planes; plane++) {
433       khr_image_attrs[attrs_index++] = EGL_DMA_BUF_PLANE0_FD_EXT + plane * 3;
434       khr_image_attrs[attrs_index++] = fds[plane];
435       khr_image_attrs[attrs_index++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT + plane * 3;
436       khr_image_attrs[attrs_index++] = gbm_bo_get_offset(bo, plane);
437       khr_image_attrs[attrs_index++] = EGL_DMA_BUF_PLANE0_PITCH_EXT + plane * 3;
438       khr_image_attrs[attrs_index++] = gbm_bo_get_stride_for_plane(bo, plane);
439       if (has_bit(egl->extension_bits, EGL_EXT_IMAGE_DMA_BUF_IMPORT_MODIFIERS)) {
440          const uint64_t modifier = gbm_bo_get_modifier(bo);
441          khr_image_attrs[attrs_index++] =
442          EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT + plane * 2;
443          khr_image_attrs[attrs_index++] = modifier & 0xfffffffful;
444          khr_image_attrs[attrs_index++] =
445          EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT + plane * 2;
446          khr_image_attrs[attrs_index++] = modifier >> 32;
447       }
448    }
449 
450    khr_image_attrs[attrs_index++] = EGL_NONE;
451    image = eglCreateImageKHR(egl->egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL,
452                              khr_image_attrs);
453 
454 out_close:
455    for (int plane = 0; plane < num_planes; plane++)
456       close(fds[plane]);
457 
458    return (void*)image;
459 }
460 
virgl_egl_aux_plane_image_from_dmabuf(struct virgl_egl * egl,struct gbm_bo * bo,int plane)461 void *virgl_egl_aux_plane_image_from_dmabuf(struct virgl_egl *egl, struct gbm_bo *bo, int plane)
462 {
463    int ret;
464    EGLImageKHR image = EGL_NO_IMAGE_KHR;
465    int fd = -1;
466 
467    int bytes_per_pixel = virgl_gbm_get_plane_bytes_per_pixel(bo, plane);
468    if (bytes_per_pixel != 1 && bytes_per_pixel != 2)
469       return (void *)EGL_NO_IMAGE_KHR;
470 
471    uint32_t handle = gbm_bo_get_handle_for_plane(bo, plane).u32;
472    ret = drmPrimeHandleToFD(gbm_device_get_fd(egl->gbm->device), handle, DRM_CLOEXEC, &fd);
473    if (ret < 0) {
474       vrend_printf("failed to export plane handle %d\n", errno);
475       return (void *)EGL_NO_IMAGE_KHR;
476    }
477 
478    EGLint khr_image_attrs[17] = {
479       EGL_WIDTH,
480       virgl_gbm_get_plane_width(bo, plane),
481       EGL_HEIGHT,
482       virgl_gbm_get_plane_height(bo, plane),
483       EGL_LINUX_DRM_FOURCC_EXT,
484       (int) (bytes_per_pixel == 1 ? GBM_FORMAT_R8 : GBM_FORMAT_GR88),
485       EGL_DMA_BUF_PLANE0_FD_EXT,
486       fd,
487       EGL_DMA_BUF_PLANE0_OFFSET_EXT,
488       gbm_bo_get_offset(bo, plane),
489       EGL_DMA_BUF_PLANE0_PITCH_EXT,
490       gbm_bo_get_stride_for_plane(bo, plane),
491    };
492 
493    if (has_bit(egl->extension_bits, EGL_EXT_IMAGE_DMA_BUF_IMPORT_MODIFIERS)) {
494       const uint64_t modifier = gbm_bo_get_modifier(bo);
495       khr_image_attrs[12] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT;
496       khr_image_attrs[13] = modifier & 0xfffffffful;
497       khr_image_attrs[14] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT;
498       khr_image_attrs[15] = modifier >> 32;
499       khr_image_attrs[16] = EGL_NONE;
500    } else {
501       khr_image_attrs[12] = EGL_NONE;
502    }
503 
504    image = eglCreateImageKHR(egl->egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, khr_image_attrs);
505 
506    close(fd);
507    return (void*)image;
508 }
509 
virgl_egl_image_destroy(struct virgl_egl * egl,void * image)510 void virgl_egl_image_destroy(struct virgl_egl *egl, void *image)
511 {
512    eglDestroyImageKHR(egl->egl_display, image);
513 }
514 #endif
515 
virgl_egl_need_fence_and_wait_external(struct virgl_egl * egl)516 bool virgl_egl_need_fence_and_wait_external(struct virgl_egl *egl)
517 {
518    return (egl && egl->need_fence_and_wait_external);
519 }
520 
virgl_egl_fence(struct virgl_egl * egl)521 void *virgl_egl_fence(struct virgl_egl *egl)
522 {
523    const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
524                                  EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR,
525                                  EGL_NONE};
526    EGLSyncKHR fence = EGL_NO_SYNC_KHR;
527 
528    if (!egl || !has_bit(egl->extension_bits, EGL_KHR_FENCE_SYNC)) {
529       return (void *)fence;
530    }
531 
532    return (void *)eglCreateSyncKHR(egl->egl_display, EGL_SYNC_FENCE_KHR, attrib_list);
533 }
534 
virgl_egl_wait_fence(struct virgl_egl * egl,void * sync)535 void virgl_egl_wait_fence(struct virgl_egl *egl, void* sync)
536 {
537    EGLSyncKHR fence = (EGLSyncKHR) sync;
538    if (fence == EGL_NO_SYNC_KHR)
539       return;
540    eglWaitSyncKHR(egl->egl_display, fence, 0);
541    eglDestroySyncKHR(egl->egl_display, fence);
542 }
543