kc3-lang/angle/src/libGLESv2/global_state.h

• Show log

  Commit

• Hash : 0a6e118d
  Author :
  Date : 2020-01-27T13:37:29
  

  Change g_Mutex from std::mutex to std::recursive_mutex
  
  When running flatland on android-10.0.0_r21 (Pixel 3), libgui's ~EglImage calls
  eglTerminate which grabs angle's EGL entry point mutex. The path continues
  to libvulkan where eventually another egl call happens (eglDestroyImageKHR) and
  it will attempt to take the mutex at the entry point again. So we try to get the
  mutex multiple times from the same thread.
  
  Change this mutex to a recursive_mutex to allow for this re-entry of EGL calls
  
  Tests: android-10.0.0_r21/frameworks/native/cmds/flatland
  Bug: angleproject:4354
  Change-Id: If8a817df45e9f58d5f06884510350e17d7127fa9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2029218
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libGLESv2/global_state.h

• //
  // Copyright 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // global_state.h : Defines functions for querying the thread-local GL and EGL state.
  
  #ifndef LIBGLESV2_GLOBALSTATE_H_
  #define LIBGLESV2_GLOBALSTATE_H_
  
  #include "libANGLE/Context.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Thread.h"
  #include "libANGLE/features.h"
  
  #include <mutex>
  
  namespace angle
  {
  using GlobalMutex = std::recursive_mutex;
  }  // namespace angle
  
  namespace egl
  {
  class Debug;
  class Thread;
  
  angle::GlobalMutex &GetGlobalMutex();
  Thread *GetCurrentThread();
  Debug *GetDebug();
  void SetContextCurrent(Thread *thread, gl::Context *context);
  }  // namespace egl
  
  #define ANGLE_SCOPED_GLOBAL_LOCK() \
      std::lock_guard<angle::GlobalMutex> globalMutexLock(egl::GetGlobalMutex())
  
  namespace gl
  {
  extern Context *gSingleThreadedContext;
  
  ANGLE_INLINE Context *GetGlobalContext()
  {
      if (gSingleThreadedContext)
      {
          return gSingleThreadedContext;
      }
  
      egl::Thread *thread = egl::GetCurrentThread();
      return thread->getContext();
  }
  
  ANGLE_INLINE Context *GetValidGlobalContext()
  {
      if (gSingleThreadedContext && !gSingleThreadedContext->isContextLost())
      {
          return gSingleThreadedContext;
      }
  
      egl::Thread *thread = egl::GetCurrentThread();
      return thread->getValidContext();
  }
  
  ANGLE_INLINE std::unique_lock<angle::GlobalMutex> GetShareGroupLock(const Context *context)
  {
      return context->isShared() ? std::unique_lock<angle::GlobalMutex>(egl::GetGlobalMutex())
                                 : std::unique_lock<angle::GlobalMutex>();
  }
  }  // namespace gl
  
  #endif  // LIBGLESV2_GLOBALSTATE_H_
  

Download