kc3-lang/angle/src/libANGLE/renderer/gl/egl/SyncEGL.cpp

• Show log

  Commit

• Hash : d0bdec30
  Author :
  Date : 2024-05-13T18:11:17
  

  EGL: Handle null resultOut for sync tail call destruction
  
  Syncs can be destroyed during eglDestroySync or as part of display
  destruction. During display distruction there is no result so
  swallow any errors.
  
  Bug: angleproject:8434
  Change-Id: I172d268c91fd0d6ba534eceff8914f9c719bdf39
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5533777
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/gl/egl/SyncEGL.cpp

• //
  // Copyright 2019 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.
  //
  
  // SyncEGL.cpp: Implements the rx::SyncEGL class.
  
  #include "libANGLE/renderer/gl/egl/SyncEGL.h"
  
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/gl/egl/FunctionsEGL.h"
  
  namespace rx
  {
  
  SyncEGL::SyncEGL(const FunctionsEGL *egl) : mEGL(egl), mSync(EGL_NO_SYNC_KHR) {}
  
  SyncEGL::~SyncEGL()
  {
      ASSERT(mSync == EGL_NO_SYNC_KHR);
  }
  
  void SyncEGL::onDestroy(const egl::Display *display)
  {
      if (mSync != EGL_NO_SYNC_KHR)
      {
          egl::Display::GetCurrentThreadUnlockedTailCall()->add(
              [egl = mEGL, sync = mSync](void *resultOut) {
                  EGLBoolean result = egl->destroySyncKHR(sync);
                  if (resultOut)
                  {
                      // It's possible for resultOut to be null if this sync is being destructed as
                      // part of display destruction.
                      *static_cast<EGLBoolean *>(resultOut) = result;
                  }
              });
          mSync = EGL_NO_SYNC_KHR;
      }
  }
  
  egl::Error SyncEGL::initialize(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLenum type,
                                 const egl::AttributeMap &attribs)
  {
      ASSERT(type == EGL_SYNC_FENCE_KHR || type == EGL_SYNC_NATIVE_FENCE_ANDROID);
  
      constexpr size_t kAttribVectorSize = 3;
      angle::FixedVector<EGLint, kAttribVectorSize> nativeAttribs;
      if (type == EGL_SYNC_NATIVE_FENCE_ANDROID)
      {
          EGLint fenceFd =
              attribs.getAsInt(EGL_SYNC_NATIVE_FENCE_FD_ANDROID, EGL_NO_NATIVE_FENCE_FD_ANDROID);
          nativeAttribs.push_back(EGL_SYNC_NATIVE_FENCE_FD_ANDROID);
          nativeAttribs.push_back(fenceFd);
      }
      nativeAttribs.push_back(EGL_NONE);
  
      egl::Display::GetCurrentThreadUnlockedTailCall()->add(
          [egl = mEGL, &sync = mSync, type, attribs = nativeAttribs](void *resultOut) {
              sync = egl->createSyncKHR(type, attribs.data());
  
              // If sync creation failed, force the return value of eglCreateSync to EGL_NO_SYNC. This
              // won't delete this sync object but a driver error is unexpected at this point.
              if (sync == EGL_NO_SYNC_KHR)
              {
                  ERR() << "eglCreateSync failed with " << gl::FmtHex(egl->getError());
                  *static_cast<EGLSync *>(resultOut) = EGL_NO_SYNC_KHR;
              }
          });
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::clientWait(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLint flags,
                                 EGLTime timeout,
                                 EGLint *outResult)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
  
      // If we need to perform a CPU wait don't set the resultOut parameter passed into the
      // method, instead set the parameter passed into the unlocked tail call.
      egl::Display::GetCurrentThreadUnlockedTailCall()->add(
          [egl = mEGL, sync = mSync, flags, timeout](void *resultOut) {
              *static_cast<EGLint *>(resultOut) = egl->clientWaitSyncKHR(sync, flags, timeout);
          });
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::serverWait(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLint flags)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
  
      egl::Display::GetCurrentThreadUnlockedTailCall()->add(
          [egl = mEGL, sync = mSync, flags](void *resultOut) {
              *static_cast<EGLBoolean *>(resultOut) = egl->waitSyncKHR(sync, flags);
          });
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::getStatus(const egl::Display *display, EGLint *outStatus)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      EGLBoolean result = mEGL->getSyncAttribKHR(mSync, EGL_SYNC_STATUS_KHR, outStatus);
  
      if (result == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglGetSyncAttribKHR with EGL_SYNC_STATUS_KHR failed");
      }
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::dupNativeFenceFD(const egl::Display *display, EGLint *result) const
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      *result = mEGL->dupNativeFenceFDANDROID(mSync);
      if (*result == EGL_NO_NATIVE_FENCE_FD_ANDROID)
      {
          return egl::Error(mEGL->getError(), "eglDupNativeFenceFDANDROID failed");
      }
  
      return egl::NoError();
  }
  
  }  // namespace rx
  

Download