Create a recursive version of MutexLock, and apply it to EGL.

This fixes one deadlock in Android's use of SwiftShader. Now fixed for
ASAN/tsan.

Bug: b/124530765
Test: atest CtsGraphicsTestCases:android.graphics.cts.BitmapTest#testDrawingHardwareBitmapNotLeaking -- --abi x86
Test: b/124530765#comment53
Signed-off-by: Cody Schuffelen <schuffelen@google.com>
Change-Id: Iacb04c0ac515eca1849d365c20efa84d58b75f72
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/28308
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
Reviewed-by: Nicolas Capens <nicolascapens@google.com>

diff --git a/src/Common/RecursiveLock.hpp b/src/Common/RecursiveLock.hpp
new file mode 100644 (file)
index 0000000..9db9295
--- /dev/null
+++ b/src/Common/RecursiveLock.hpp
@@ -0,0 +1,72 @@
+// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_RecursiveLock_hpp
+#define sw_RecursiveLock_hpp
+
+#include "Thread.hpp"
+
+#include <mutex>
+
+namespace sw
+{
+       class RecursiveLock
+       {
+       public:
+               RecursiveLock()
+               {
+               }
+
+               bool attemptLock()
+               {
+                       return mutex.try_lock();
+               }
+
+               void lock()
+               {
+                       mutex.lock();
+               }
+
+               void unlock()
+               {
+                       mutex.unlock();
+               }
+       private:
+               std::recursive_mutex mutex;
+       };
+}
+
+class RecursiveLockGuard
+{
+public:
+       explicit RecursiveLockGuard(sw::RecursiveLock &mutex) : mutex(&mutex)
+       {
+               mutex.lock();
+       }
+
+       explicit RecursiveLockGuard(sw::RecursiveLock *mutex) : mutex(mutex)
+       {
+               if (mutex) mutex->lock();
+       }
+
+       ~RecursiveLockGuard()
+       {
+               if (mutex) mutex->unlock();
+       }
+
+protected:
+       sw::RecursiveLock *mutex;
+};
+
+#endif   // sw_RecursiveLock_hpp

diff --git a/src/OpenGL/libEGL/Display.cpp b/src/OpenGL/libEGL/Display.cpp
index 1b9bacf..ac525f0 100644 (file)
--- a/src/OpenGL/libEGL/Display.cpp
+++ b/src/OpenGL/libEGL/Display.cpp
@@ -23,7 +23,7 @@
 #include "libEGL/Context.hpp"
 #include "common/Image.hpp"
 #include "common/debug.h"
-#include "Common/MutexLock.hpp"
+#include "Common/RecursiveLock.hpp"
 
 #ifdef __ANDROID__
 #include <system/window.h>

diff --git a/src/OpenGL/libEGL/Display.h b/src/OpenGL/libEGL/Display.h
index 53ebdfb..a187e21 100644 (file)
--- a/src/OpenGL/libEGL/Display.h
+++ b/src/OpenGL/libEGL/Display.h
@@ -20,8 +20,8 @@
 #define INCLUDE_DISPLAY_H_
 
 #include "Config.h"
-#include "Common/MutexLock.hpp"
 #include "Sync.hpp"
+#include "Common/RecursiveLock.hpp"
 #include "common/NameSpace.hpp"
 
 #include <set>
@@ -86,7 +86,7 @@ namespace egl
                bool destroySharedImage(EGLImageKHR);
                virtual Image *getSharedImage(EGLImageKHR name) = 0;
 
-               sw::MutexLock *getLock() { return &mApiMutex; }
+               sw::RecursiveLock *getLock() { return &mApiMutex; }
 
        private:
                sw::Format getDisplayFormat() const;
@@ -109,7 +109,7 @@ namespace egl
                SyncSet mSyncSet;
 
                gl::NameSpace<Image> mSharedImageNameSpace;
-               sw::MutexLock mApiMutex;
+               sw::RecursiveLock mApiMutex;
        };
 }
 

diff --git a/src/OpenGL/libEGL/main.cpp b/src/OpenGL/libEGL/main.cpp
index d86e80b..5b60037 100644 (file)
--- a/src/OpenGL/libEGL/main.cpp
+++ b/src/OpenGL/libEGL/main.cpp
@@ -340,7 +340,7 @@ void error(EGLint errorCode)
        }
 }
 
-sw::MutexLock *getDisplayLock(EGLDisplay dpy)
+sw::RecursiveLock *getDisplayLock(EGLDisplay dpy)
 {
        auto display = Display::get(dpy);
        if (!display) return nullptr;
@@ -415,67 +415,67 @@ EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
 
 EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::Initialize(dpy, major, minor);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::Terminate(dpy);
 }
 
 EGLAPI const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::QueryString(dpy, name);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::GetConfigs(dpy, configs, config_size, num_config);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::GetConfigAttrib(dpy, config, attribute, value);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateWindowSurface(dpy, config, window, attrib_list);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePbufferSurface(dpy, config, attrib_list);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroySurface(dpy, surface);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::QuerySurface(dpy, surface, attribute, value);
 }
 
@@ -501,49 +501,49 @@ EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void)
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::SurfaceAttrib(dpy, surface, attribute, value);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::BindTexImage(dpy, surface, buffer);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ReleaseTexImage(dpy, surface, buffer);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::SwapInterval(dpy, interval);
 }
 
 EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateContext(dpy, config, share_context, attrib_list);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroyContext(dpy, ctx);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::MakeCurrent(dpy, draw, read, ctx);
 }
 
@@ -564,7 +564,7 @@ EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
 
 EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::QueryContext(dpy, ctx, attribute, value);
 }
 
@@ -580,37 +580,37 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
 
 EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::SwapBuffers(dpy, surface);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CopyBuffers(dpy, surface, target);
 }
 
 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);
 }
 
 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateImage(dpy, ctx, target, buffer, attrib_list);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroyImageKHR(dpy, image);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImage(EGLDisplay dpy, EGLImageKHR image)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroyImageKHR(dpy, image);
 }
 
@@ -626,85 +626,85 @@ EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay(EGLenum platform, void *nati
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePlatformWindowSurfaceEXT(dpy, config, native_window, attrib_list);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePlatformPixmapSurfaceEXT(dpy, config, native_pixmap, attrib_list);
 }
 
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
 }
 
 EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateSyncKHR(dpy, type, attrib_list);
 }
 
 EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::CreateSync(dpy, type, attrib_list);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroySyncKHR(dpy, sync);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync(EGLDisplay dpy, EGLSyncKHR sync)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::DestroySyncKHR(dpy, sync);
 }
 
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
 }
 
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSync(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::GetSyncAttribKHR(dpy, sync, attribute, value);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLAttrib *value)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::GetSyncAttrib(dpy, sync, attribute, value);
 }
 
 EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
 }
 
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
 {
-       LockGuard lock(egl::getDisplayLock(dpy));
+       RecursiveLockGuard lock(egl::getDisplayLock(dpy));
        return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
 }