[Mesa-dev] [PATCH 2/2] st/mesa: allow multiple concurrent waiters in ClientWaitSync

[Marek Olšák]

From: Marek Olšák <marek.olsak at amd.com>

so->fence can be unreferenced by one thread while another thread is
somewhere in ClientWaitSync and expecting so->fence to be non-NULL.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=98172

Cc: 12.0 13.0 <mesa-stable at lists.freedesktop.org>
---
 src/mesa/state_tracker/st_cb_syncobj.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/mesa/state_tracker/st_cb_syncobj.c b/src/mesa/state_tracker/st_cb_syncobj.c
index 749c124..7a4ba71 100644
--- a/src/mesa/state_tracker/st_cb_syncobj.c
+++ b/src/mesa/state_tracker/st_cb_syncobj.c
@@ -34,39 +34,45 @@
 #include "main/macros.h"
 #include "pipe/p_context.h"
 #include "pipe/p_screen.h"
 #include "st_context.h"
 #include "st_cb_syncobj.h"
 
 struct st_sync_object {
    struct gl_sync_object b;
 
    struct pipe_fence_handle *fence;
+   mtx_t mutex; /**< protects "fence" */
 };
 
 
 static struct gl_sync_object * st_new_sync_object(struct gl_context *ctx,
                                                   GLenum type)
 {
-   if (type == GL_SYNC_FENCE)
-      return (struct gl_sync_object*)CALLOC_STRUCT(st_sync_object);
-   else
+   if (type == GL_SYNC_FENCE) {
+      struct st_sync_object *so = CALLOC_STRUCT(st_sync_object);
+
+      mtx_init(&so->mutex, mtx_plain);
+      return &so->b;
+   } else {
       return NULL;
+   }
 }
 
 static void st_delete_sync_object(struct gl_context *ctx,
                                   struct gl_sync_object *obj)
 {
    struct pipe_screen *screen = st_context(ctx)->pipe->screen;
    struct st_sync_object *so = (struct st_sync_object*)obj;
 
    screen->fence_reference(screen, &so->fence, NULL);
+   mtx_destroy(&so->mutex);
    free(so->b.Label);
    free(so);
 }
 
 static void st_fence_sync(struct gl_context *ctx, struct gl_sync_object *obj,
                           GLenum condition, GLbitfield flags)
 {
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_sync_object *so = (struct st_sync_object*)obj;
 
@@ -76,43 +82,55 @@ static void st_fence_sync(struct gl_context *ctx, struct gl_sync_object *obj,
    pipe->flush(pipe, &so->fence, PIPE_FLUSH_DEFERRED);
 }
 
 static void st_client_wait_sync(struct gl_context *ctx,
                                 struct gl_sync_object *obj,
                                 GLbitfield flags, GLuint64 timeout)
 {
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct pipe_screen *screen = pipe->screen;
    struct st_sync_object *so = (struct st_sync_object*)obj;
+   struct pipe_fence_handle *fence = NULL;
 
    /* If the fence doesn't exist, assume it's signalled. */
+   mtx_lock(&so->mutex);
    if (!so->fence) {
+      mtx_unlock(&so->mutex);
       so->b.StatusFlag = GL_TRUE;
       return;
    }
 
+   /* We need a local copy of the fence pointer, so that we can call
+    * fence_finish unlocked.
+    */
+   screen->fence_reference(screen, &fence, so->fence);
+   mtx_unlock(&so->mutex);
+
    /* Section 4.1.2 of OpenGL 4.5 (Compatibility Profile) says:
     *    [...] if ClientWaitSync is called and all of the following are true:
     *    - the SYNC_FLUSH_COMMANDS_BIT bit is set in flags,
     *    - sync is unsignaled when ClientWaitSync is called,
     *    - and the calls to ClientWaitSync and FenceSync were issued from
     *      the same context,
     *    then the GL will behave as if the equivalent of Flush were inserted
     *    immediately after the creation of sync.
     *
     * Assume GL_SYNC_FLUSH_COMMANDS_BIT is always set, because applications
     * forget to set it.
     */
-   if (screen->fence_finish(screen, pipe, so->fence, timeout)) {
+   if (screen->fence_finish(screen, pipe, fence, timeout)) {
+      mtx_lock(&so->mutex);
       screen->fence_reference(screen, &so->fence, NULL);
+      mtx_unlock(&so->mutex);
       so->b.StatusFlag = GL_TRUE;
    }
+   screen->fence_reference(screen, &fence, NULL);
 }
 
 static void st_check_sync(struct gl_context *ctx, struct gl_sync_object *obj)
 {
    st_client_wait_sync(ctx, obj, 0, 0);
 }
 
 static void st_server_wait_sync(struct gl_context *ctx,
                                 struct gl_sync_object *obj,
                                 GLbitfield flags, GLuint64 timeout)
-- 
2.7.4