From ef20e4e8052e0ae02e37dbba1d4663cb09839a0b Mon Sep 17 00:00:00 2001 From: Peiyong Lin Date: Mon, 3 Jul 2023 02:33:00 +0000 Subject: [Cherry-pick] Group methods with similar purpose. Bug: b/283858001 Test: atest CtsAngleDeveloperOptionHostTest -c Change-Id: I8654b19d3a582477ea59cbff875b5ecf0817d06d Merged-In: I8654b19d3a582477ea59cbff875b5ecf0817d06d --- libs/graphicsenv/GraphicsEnv.cpp | 306 ++++++++++++++++++++------------------- 1 file changed, 161 insertions(+), 145 deletions(-) diff --git a/libs/graphicsenv/GraphicsEnv.cpp b/libs/graphicsenv/GraphicsEnv.cpp index 1adf1afaa2..ed5d5c1095 100644 --- a/libs/graphicsenv/GraphicsEnv.cpp +++ b/libs/graphicsenv/GraphicsEnv.cpp @@ -138,6 +138,16 @@ static const std::string getSystemNativeLibraries(NativeLibrary type) { return base::Join(soNames, ':'); } +static sp getGpuService() { + static const sp binder = defaultServiceManager()->checkService(String16("gpu")); + if (!binder) { + ALOGE("Failed to get gpu service"); + return nullptr; + } + + return interface_cast(binder); +} + /*static*/ GraphicsEnv& GraphicsEnv::getInstance() { static GraphicsEnv env; return env; @@ -160,6 +170,10 @@ bool GraphicsEnv::isDebuggable() { return appDebuggable || platformDebuggable; } +/** + * APIs for updatable graphics drivers + */ + void GraphicsEnv::setDriverPathAndSphalLibraries(const std::string& path, const std::string& sphalLibraries) { if (!mDriverPath.empty() || !mSphalLibraries.empty()) { @@ -174,6 +188,108 @@ void GraphicsEnv::setDriverPathAndSphalLibraries(const std::string& path, mSphalLibraries = sphalLibraries; } +// Return true if all the required libraries from vndk and sphal namespace are +// linked to the driver namespace correctly. +bool GraphicsEnv::linkDriverNamespaceLocked(android_namespace_t* destNamespace, + android_namespace_t* vndkNamespace, + const std::string& sharedSphalLibraries) { + const std::string llndkLibraries = getSystemNativeLibraries(NativeLibrary::LLNDK); + if (llndkLibraries.empty()) { + return false; + } + if (!android_link_namespaces(destNamespace, nullptr, llndkLibraries.c_str())) { + ALOGE("Failed to link default namespace[%s]", dlerror()); + return false; + } + + const std::string vndkspLibraries = getSystemNativeLibraries(NativeLibrary::VNDKSP); + if (vndkspLibraries.empty()) { + return false; + } + if (!android_link_namespaces(destNamespace, vndkNamespace, vndkspLibraries.c_str())) { + ALOGE("Failed to link vndk namespace[%s]", dlerror()); + return false; + } + + if (sharedSphalLibraries.empty()) { + return true; + } + + // Make additional libraries in sphal to be accessible + auto sphalNamespace = android_get_exported_namespace("sphal"); + if (!sphalNamespace) { + ALOGE("Depend on these libraries[%s] in sphal, but failed to get sphal namespace", + sharedSphalLibraries.c_str()); + return false; + } + + if (!android_link_namespaces(destNamespace, sphalNamespace, sharedSphalLibraries.c_str())) { + ALOGE("Failed to link sphal namespace[%s]", dlerror()); + return false; + } + + return true; +} + +android_namespace_t* GraphicsEnv::getDriverNamespace() { + std::lock_guard lock(mNamespaceMutex); + + if (mDriverNamespace) { + return mDriverNamespace; + } + + if (mDriverPath.empty()) { + // For an application process, driver path is empty means this application is not opted in + // to use updatable driver. Application process doesn't have the ability to set up + // environment variables and hence before `getenv` call will return. + // For a process that is not an application process, if it's run from an environment, + // for example shell, where environment variables can be set, then it can opt into using + // udpatable driver by setting UPDATABLE_GFX_DRIVER to 1. By setting to 1 the developer + // driver will be used currently. + // TODO(b/159240322) Support the production updatable driver. + const char* id = getenv("UPDATABLE_GFX_DRIVER"); + if (id == nullptr || std::strcmp(id, "1") != 0) { + return nullptr; + } + const sp gpuService = getGpuService(); + if (!gpuService) { + return nullptr; + } + mDriverPath = gpuService->getUpdatableDriverPath(); + if (mDriverPath.empty()) { + return nullptr; + } + mDriverPath.append(UPDATABLE_DRIVER_ABI); + ALOGI("Driver path is setup via UPDATABLE_GFX_DRIVER: %s", mDriverPath.c_str()); + } + + auto vndkNamespace = android_get_exported_namespace("vndk"); + if (!vndkNamespace) { + return nullptr; + } + + mDriverNamespace = android_create_namespace("updatable gfx driver", + mDriverPath.c_str(), // ld_library_path + mDriverPath.c_str(), // default_library_path + ANDROID_NAMESPACE_TYPE_ISOLATED, + nullptr, // permitted_when_isolated_path + nullptr); + + if (!linkDriverNamespaceLocked(mDriverNamespace, vndkNamespace, mSphalLibraries)) { + mDriverNamespace = nullptr; + } + + return mDriverNamespace; +} + +std::string GraphicsEnv::getDriverPath() const { + return mDriverPath; +} + +/** + * APIs for GpuStats + */ + void GraphicsEnv::hintActivityLaunch() { ATRACE_CALL(); @@ -328,16 +444,6 @@ void GraphicsEnv::setVulkanDeviceExtensions(uint32_t enabledExtensionCount, extensionHashes, numStats); } -static sp getGpuService() { - static const sp binder = defaultServiceManager()->checkService(String16("gpu")); - if (!binder) { - ALOGE("Failed to get gpu service"); - return nullptr; - } - - return interface_cast(binder); -} - bool GraphicsEnv::readyToSendGpuStatsLocked() { // Only send stats for processes having at least one activity launched and that process doesn't // skip the GraphicsEnvironment setup. @@ -410,6 +516,10 @@ bool GraphicsEnv::setInjectLayersPrSetDumpable() { return true; } +/** + * APIs for ANGLE + */ + bool GraphicsEnv::shouldUseAngle() { // Make sure we are init'ed if (mPackageName.empty()) { @@ -441,30 +551,15 @@ void GraphicsEnv::setAngleInfo(const std::string& path, const bool shouldUseNati mAnglePath = std::move(path); ALOGV("setting app package name to '%s'", packageName.c_str()); mPackageName = std::move(packageName); - if (path == "system") { + if (mAnglePath == "system") { mShouldUseSystemAngle = true; } - if (!path.empty()) { + if (!mAnglePath.empty()) { mShouldUseAngle = true; } mShouldUseNativeDriver = shouldUseNativeDriver; } -void GraphicsEnv::setLayerPaths(NativeLoaderNamespace* appNamespace, - const std::string& layerPaths) { - if (mLayerPaths.empty()) { - mLayerPaths = layerPaths; - mAppNamespace = appNamespace; - } else { - ALOGV("Vulkan layer search path already set, not clobbering with '%s' for namespace %p'", - layerPaths.c_str(), appNamespace); - } -} - -NativeLoaderNamespace* GraphicsEnv::getAppNamespace() { - return mAppNamespace; -} - std::string& GraphicsEnv::getPackageName() { return mPackageName; } @@ -473,124 +568,6 @@ const std::vector& GraphicsEnv::getAngleEglFeatures() { return mAngleEglFeatures; } -const std::string& GraphicsEnv::getLayerPaths() { - return mLayerPaths; -} - -const std::string& GraphicsEnv::getDebugLayers() { - return mDebugLayers; -} - -const std::string& GraphicsEnv::getDebugLayersGLES() { - return mDebugLayersGLES; -} - -void GraphicsEnv::setDebugLayers(const std::string& layers) { - mDebugLayers = layers; -} - -void GraphicsEnv::setDebugLayersGLES(const std::string& layers) { - mDebugLayersGLES = layers; -} - -// Return true if all the required libraries from vndk and sphal namespace are -// linked to the driver namespace correctly. -bool GraphicsEnv::linkDriverNamespaceLocked(android_namespace_t* destNamespace, - android_namespace_t* vndkNamespace, - const std::string& sharedSphalLibraries) { - const std::string llndkLibraries = getSystemNativeLibraries(NativeLibrary::LLNDK); - if (llndkLibraries.empty()) { - return false; - } - if (!android_link_namespaces(destNamespace, nullptr, llndkLibraries.c_str())) { - ALOGE("Failed to link default namespace[%s]", dlerror()); - return false; - } - - const std::string vndkspLibraries = getSystemNativeLibraries(NativeLibrary::VNDKSP); - if (vndkspLibraries.empty()) { - return false; - } - if (!android_link_namespaces(destNamespace, vndkNamespace, vndkspLibraries.c_str())) { - ALOGE("Failed to link vndk namespace[%s]", dlerror()); - return false; - } - - if (sharedSphalLibraries.empty()) { - return true; - } - - // Make additional libraries in sphal to be accessible - auto sphalNamespace = android_get_exported_namespace("sphal"); - if (!sphalNamespace) { - ALOGE("Depend on these libraries[%s] in sphal, but failed to get sphal namespace", - sharedSphalLibraries.c_str()); - return false; - } - - if (!android_link_namespaces(destNamespace, sphalNamespace, sharedSphalLibraries.c_str())) { - ALOGE("Failed to link sphal namespace[%s]", dlerror()); - return false; - } - - return true; -} - -android_namespace_t* GraphicsEnv::getDriverNamespace() { - std::lock_guard lock(mNamespaceMutex); - - if (mDriverNamespace) { - return mDriverNamespace; - } - - if (mDriverPath.empty()) { - // For an application process, driver path is empty means this application is not opted in - // to use updatable driver. Application process doesn't have the ability to set up - // environment variables and hence before `getenv` call will return. - // For a process that is not an application process, if it's run from an environment, - // for example shell, where environment variables can be set, then it can opt into using - // udpatable driver by setting UPDATABLE_GFX_DRIVER to 1. By setting to 1 the developer - // driver will be used currently. - // TODO(b/159240322) Support the production updatable driver. - const char* id = getenv("UPDATABLE_GFX_DRIVER"); - if (id == nullptr || std::strcmp(id, "1")) { - return nullptr; - } - const sp gpuService = getGpuService(); - if (!gpuService) { - return nullptr; - } - mDriverPath = gpuService->getUpdatableDriverPath(); - if (mDriverPath.empty()) { - return nullptr; - } - mDriverPath.append(UPDATABLE_DRIVER_ABI); - ALOGI("Driver path is setup via UPDATABLE_GFX_DRIVER: %s", mDriverPath.c_str()); - } - - auto vndkNamespace = android_get_exported_namespace("vndk"); - if (!vndkNamespace) { - return nullptr; - } - - mDriverNamespace = android_create_namespace("updatable gfx driver", - mDriverPath.c_str(), // ld_library_path - mDriverPath.c_str(), // default_library_path - ANDROID_NAMESPACE_TYPE_ISOLATED, - nullptr, // permitted_when_isolated_path - nullptr); - - if (!linkDriverNamespaceLocked(mDriverNamespace, vndkNamespace, mSphalLibraries)) { - mDriverNamespace = nullptr; - } - - return mDriverNamespace; -} - -std::string GraphicsEnv::getDriverPath() const { - return mDriverPath; -} - android_namespace_t* GraphicsEnv::getAngleNamespace() { std::lock_guard lock(mNamespaceMutex); @@ -661,4 +638,43 @@ bool GraphicsEnv::shouldUseNativeDriver() { return mShouldUseNativeDriver; } +/** + * APIs for debuggable layers + */ + +void GraphicsEnv::setLayerPaths(NativeLoaderNamespace* appNamespace, + const std::string& layerPaths) { + if (mLayerPaths.empty()) { + mLayerPaths = layerPaths; + mAppNamespace = appNamespace; + } else { + ALOGV("Vulkan layer search path already set, not clobbering with '%s' for namespace %p'", + layerPaths.c_str(), appNamespace); + } +} + +NativeLoaderNamespace* GraphicsEnv::getAppNamespace() { + return mAppNamespace; +} + +const std::string& GraphicsEnv::getLayerPaths() { + return mLayerPaths; +} + +const std::string& GraphicsEnv::getDebugLayers() { + return mDebugLayers; +} + +const std::string& GraphicsEnv::getDebugLayersGLES() { + return mDebugLayersGLES; +} + +void GraphicsEnv::setDebugLayers(const std::string& layers) { + mDebugLayers = layers; +} + +void GraphicsEnv::setDebugLayersGLES(const std::string& layers) { + mDebugLayersGLES = layers; +} + } // namespace android -- cgit v1.2.3-59-g8ed1b