events: unlock notifier event on failed event

When a device notifies that an event failed,
the wait event eventually ends up in
pocl_update_event_finished. This function will
lock the command queue. But since the notify
event is locked in common.c:broadcast, a lock
order violation can occur as the command queue is
locked after the notifier event. This is in
contrast to the lock order in other places where
where it is first cq then event.
This commit solves this by unlocking the notifier
event before calling pocl_update_event_failed.

Author: RABijl

lib/CL/devices/basic/basic.c

@@ -571,7 +571,16 @@ pocl_basic_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder (event, finished);
+      pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder (finished, event);
       return;
     }
 

lib/CL/devices/hsa/pocl-hsa.c

@@ -1613,7 +1613,16 @@ pocl_hsa_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder (event, finished);
+      pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder (finished, event);
       return;
     }
 

lib/CL/devices/proxy/pocl_proxy.cpp

@@ -1750,7 +1750,16 @@ pocl_proxy_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder(event, finished);
+      pocl_update_event_failed(CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder(finished, event);
       return;
     }
 

lib/CL/devices/pthread/pthread.c

@@ -258,7 +258,16 @@ pocl_pthread_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder (event, finished);
+      pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder (finished, event);
       return;
     }
 

lib/CL/devices/remote/remote.c

@@ -1595,7 +1595,16 @@ pocl_remote_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder (event, finished);
+      pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder (finished, event);
       return;
     }
 

lib/CL/devices/tbb/tbb.c

@@ -286,9 +286,19 @@ void pocl_tbb_notify(cl_device_id device, cl_event event, cl_event finished) {
   cl_bool wake_thread = CL_FALSE;
   _cl_command_node *node = event->command;
 
-  if (finished->status < CL_COMPLETE) {
-      pocl_update_event_failed_locked (event);
-      return;
+  if (finished->status < CL_COMPLETE)
+  {
+    /* Unlock the finished event in order to prevent a lock order violation
+     * with the command queue that will be locked during
+     * pocl_update_event_failed.
+     */
+    pocl_unlock_events_inorder (event, finished);
+    pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+    /* Lock events in this order to avoid a lock order violation between
+     * the finished/notifier and event/wait events.
+     */
+    pocl_lock_events_inorder (finished, event);
+    return;
   }
 
   if (node->state != POCL_COMMAND_READY)

lib/CL/devices/tce/tce_common.cc

@@ -1170,8 +1170,18 @@ pocl_tce_notify (cl_device_id device, cl_event event, cl_event finished)
 {
   _cl_command_node *node = event->command;
 
-  if (finished->status < CL_COMPLETE) {
-    pocl_update_event_failed_locked(event);
+  if (finished->status < CL_COMPLETE)
+  {
+    /* Unlock the finished event in order to prevent a lock order violation
+     * with the command queue that will be locked during
+     * pocl_update_event_failed.
+     */
+    pocl_unlock_events_inorder(event, finished);
+    pocl_update_event_failed(CL_FAILED, NULL, 0, event, NULL);
+    /* Lock events in this order to avoid a lock order violation between
+     * the finished/notifier and event/wait events.
+     */
+    pocl_lock_events_inorder(finished, event);
     return;
   }
 

lib/CL/devices/vulkan/pocl-vulkan.c

@@ -2935,7 +2935,16 @@ pocl_vulkan_notify (cl_device_id device, cl_event event, cl_event finished)
 
   if (finished->status < CL_COMPLETE)
     {
-      pocl_update_event_failed_locked (event);
+      /* Unlock the finished event in order to prevent a lock order violation
+       * with the command queue that will be locked during
+       * pocl_update_event_failed.
+       */
+      pocl_unlock_events_inorder (event, finished);
+      pocl_update_event_failed (CL_FAILED, NULL, 0, event, NULL);
+      /* Lock events in this order to avoid a lock order violation between
+       * the finished/notifier and event/wait events.
+       */
+      pocl_lock_events_inorder (finished, event);
       return;
     }
 

lib/CL/pocl_util.h

@@ -92,8 +92,8 @@ void pocl_aligned_free (void *ptr);
 /* locks / unlocks two events in order of their event-id.
  * This avoids any potential deadlocks of threads should
  * they try to lock events in opposite order. */
-void pocl_lock_events_inorder (cl_event ev1, cl_event ev2);
-void pocl_unlock_events_inorder (cl_event ev1, cl_event ev2);
+POCL_EXPORT void pocl_lock_events_inorder (cl_event ev1, cl_event ev2);
+POCL_EXPORT void pocl_unlock_events_inorder (cl_event ev1, cl_event ev2);
 
 /* Function for creating events */
 cl_int pocl_create_event (cl_event *event,