libs/graphicsenv/GraphicsEnv.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2017 The Android Open Source Project
  *
  * 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.
  */

 #define ATRACE_TAG ATRACE_TAG_GRAPHICS

 //#define LOG_NDEBUG 1
 #define LOG_TAG "GraphicsEnv"

 #include <graphicsenv/GraphicsEnv.h>

 #include <dlfcn.h>
 #include <unistd.h>

 #include <android-base/file.h>
 #include <android-base/properties.h>
 #include <android-base/strings.h>
 #include <android/dlext.h>
 #include <binder/IServiceManager.h>
 #include <cutils/properties.h>
 #include <graphicsenv/IGpuService.h>
 #include <log/log.h>
 #include <nativeloader/dlext_namespaces.h>
 #include <sys/prctl.h>
 #include <utils/Trace.h>

 #include <memory>
 #include <string>
 #include <thread>

 // TODO(b/159240322): Extend this to x86 ABI.
 #if defined(__LP64__)
 #define UPDATABLE_DRIVER_ABI "arm64-v8a"
 #else
 #define UPDATABLE_DRIVER_ABI "armeabi-v7a"
 #endif // defined(__LP64__)

 // TODO(ianelliott@): Get the following from an ANGLE header:
 #define CURRENT_ANGLE_API_VERSION 2 // Current API verion we are targetting
 // Version-2 API:
 typedef bool (*fpANGLEGetFeatureSupportUtilAPIVersion)(unsigned int* versionToUse);
 typedef bool (*fpANGLEAndroidParseRulesString)(const char* rulesString, void** rulesHandle,
                                                int* rulesVersion);
 typedef bool (*fpANGLEGetSystemInfo)(void** handle);
 typedef bool (*fpANGLEAddDeviceInfoToSystemInfo)(const char* deviceMfr, const char* deviceModel,
                                                  void* handle);
 typedef bool (*fpANGLEShouldBeUsedForApplication)(void* rulesHandle, int rulesVersion,
                                                   void* systemInfoHandle, const char* appName);
 typedef bool (*fpANGLEFreeRulesHandle)(void* handle);
 typedef bool (*fpANGLEFreeSystemInfoHandle)(void* handle);

 namespace android {

 enum NativeLibrary {
     LLNDK = 0,
     VNDKSP = 1,
 };

 static constexpr const char* kNativeLibrariesSystemConfigPath[] =
         {"/apex/com.android.vndk.v{}/etc/llndk.libraries.{}.txt",
          "/apex/com.android.vndk.v{}/etc/vndksp.libraries.{}.txt"};

 static std::string vndkVersionStr() {
 #ifdef __BIONIC__
     return android::base::GetProperty("ro.vndk.version", "");
 #endif
     return "";
 }

 static void insertVndkVersionStr(std::string* fileName) {
     LOG_ALWAYS_FATAL_IF(!fileName, "fileName should never be nullptr");
     std::string version = vndkVersionStr();
     size_t pos = fileName->find("{}");
     while (pos != std::string::npos) {
         fileName->replace(pos, 2, version);
         pos = fileName->find("{}", pos + version.size());
     }
 }

 static bool readConfig(const std::string& configFile, std::vector<std::string>* soNames) {
     // Read list of public native libraries from the config file.
     std::string fileContent;
     if (!base::ReadFileToString(configFile, &fileContent)) {
         return false;
     }

     std::vector<std::string> lines = base::Split(fileContent, "\n");

     for (auto& line : lines) {
         auto trimmedLine = base::Trim(line);
         if (!trimmedLine.empty()) {
             soNames->push_back(trimmedLine);
         }
     }

     return true;
 }

 static const std::string getSystemNativeLibraries(NativeLibrary type) {
     std::string nativeLibrariesSystemConfig = kNativeLibrariesSystemConfigPath[type];
     insertVndkVersionStr(&nativeLibrariesSystemConfig);

     std::vector<std::string> soNames;
     if (!readConfig(nativeLibrariesSystemConfig, &soNames)) {
         ALOGE("Failed to retrieve library names from %s", nativeLibrariesSystemConfig.c_str());
         return "";
     }

     return base::Join(soNames, ':');
 }

 /*static*/ GraphicsEnv& GraphicsEnv::getInstance() {
     static GraphicsEnv env;
     return env;
 }

 bool GraphicsEnv::isDebuggable() {
     return prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) > 0;
 }

 void GraphicsEnv::setDriverPathAndSphalLibraries(const std::string path,
                                                  const std::string sphalLibraries) {
     if (!mDriverPath.empty() || !mSphalLibraries.empty()) {
         ALOGV("ignoring attempt to change driver path from '%s' to '%s' or change sphal libraries "
               "from '%s' to '%s'",
               mDriverPath.c_str(), path.c_str(), mSphalLibraries.c_str(), sphalLibraries.c_str());
         return;
     }
     ALOGV("setting driver path to '%s' and sphal libraries to '%s'", path.c_str(),
           sphalLibraries.c_str());
     mDriverPath = path;
     mSphalLibraries = sphalLibraries;
 }

 void GraphicsEnv::hintActivityLaunch() {
     ATRACE_CALL();

     {
         std::lock_guard<std::mutex> lock(mStatsLock);
         if (mActivityLaunched) return;
         mActivityLaunched = true;
     }

     std::thread trySendGpuStatsThread([this]() {
         // If there's already graphics driver preloaded in the process, just send
         // the stats info to GpuStats directly through async binder.
         std::lock_guard<std::mutex> lock(mStatsLock);
         if (mGpuStats.glDriverToSend) {
             mGpuStats.glDriverToSend = false;
             sendGpuStatsLocked(GpuStatsInfo::Api::API_GL, true, mGpuStats.glDriverLoadingTime);
         }
         if (mGpuStats.vkDriverToSend) {
             mGpuStats.vkDriverToSend = false;
             sendGpuStatsLocked(GpuStatsInfo::Api::API_VK, true, mGpuStats.vkDriverLoadingTime);
         }
     });
     trySendGpuStatsThread.detach();
 }

 void GraphicsEnv::setGpuStats(const std::string& driverPackageName,
                               const std::string& driverVersionName, uint64_t driverVersionCode,
                               int64_t driverBuildTime, const std::string& appPackageName,
                               const int vulkanVersion) {
     ATRACE_CALL();

     std::lock_guard<std::mutex> lock(mStatsLock);
     ALOGV("setGpuStats:\n"
           "\tdriverPackageName[%s]\n"
           "\tdriverVersionName[%s]\n"
           "\tdriverVersionCode[%" PRIu64 "]\n"
           "\tdriverBuildTime[%" PRId64 "]\n"
           "\tappPackageName[%s]\n"
           "\tvulkanVersion[%d]\n",
           driverPackageName.c_str(), driverVersionName.c_str(), driverVersionCode, driverBuildTime,
           appPackageName.c_str(), vulkanVersion);

     mGpuStats.driverPackageName = driverPackageName;
     mGpuStats.driverVersionName = driverVersionName;
     mGpuStats.driverVersionCode = driverVersionCode;
     mGpuStats.driverBuildTime = driverBuildTime;
     mGpuStats.appPackageName = appPackageName;
     mGpuStats.vulkanVersion = vulkanVersion;
 }

 void GraphicsEnv::setDriverToLoad(GpuStatsInfo::Driver driver) {
     ATRACE_CALL();

     std::lock_guard<std::mutex> lock(mStatsLock);
     switch (driver) {
         case GpuStatsInfo::Driver::GL:
         case GpuStatsInfo::Driver::GL_UPDATED:
         case GpuStatsInfo::Driver::ANGLE: {
             if (mGpuStats.glDriverToLoad == GpuStatsInfo::Driver::NONE ||
                 mGpuStats.glDriverToLoad == GpuStatsInfo::Driver::GL) {
                 mGpuStats.glDriverToLoad = driver;
                 break;
             }

             if (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE) {
                 mGpuStats.glDriverFallback = driver;
             }
             break;
         }
         case GpuStatsInfo::Driver::VULKAN:
         case GpuStatsInfo::Driver::VULKAN_UPDATED: {
             if (mGpuStats.vkDriverToLoad == GpuStatsInfo::Driver::NONE ||
                 mGpuStats.vkDriverToLoad == GpuStatsInfo::Driver::VULKAN) {
                 mGpuStats.vkDriverToLoad = driver;
                 break;
             }

             if (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE) {
                 mGpuStats.vkDriverFallback = driver;
             }
             break;
         }
         default:
             break;
     }
 }

 void GraphicsEnv::setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded,
                                   int64_t driverLoadingTime) {
     ATRACE_CALL();

     std::lock_guard<std::mutex> lock(mStatsLock);
     if (api == GpuStatsInfo::Api::API_GL) {
         mGpuStats.glDriverToSend = true;
         mGpuStats.glDriverLoadingTime = driverLoadingTime;
     } else {
         mGpuStats.vkDriverToSend = true;
         mGpuStats.vkDriverLoadingTime = driverLoadingTime;
     }

     sendGpuStatsLocked(api, isDriverLoaded, driverLoadingTime);
 }

 static sp<IGpuService> getGpuService() {
     static const sp<IBinder> binder = defaultServiceManager()->checkService(String16("gpu"));
     if (!binder) {
         ALOGE("Failed to get gpu service");
         return nullptr;
     }

     return interface_cast<IGpuService>(binder);
 }

 bool GraphicsEnv::readyToSendGpuStatsLocked() {
     // Only send stats for processes having at least one activity launched and that process doesn't
     // skip the GraphicsEnvironment setup.
     return mActivityLaunched && !mGpuStats.appPackageName.empty();
 }

 void GraphicsEnv::setTargetStats(const GpuStatsInfo::Stats stats, const uint64_t value) {
     ATRACE_CALL();

     std::lock_guard<std::mutex> lock(mStatsLock);
     if (!readyToSendGpuStatsLocked()) return;

     const sp<IGpuService> gpuService = getGpuService();
     if (gpuService) {
         gpuService->setTargetStats(mGpuStats.appPackageName, mGpuStats.driverVersionCode, stats,
                                    value);
     }
 }

 void GraphicsEnv::sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded,
                                      int64_t driverLoadingTime) {
     ATRACE_CALL();

     if (!readyToSendGpuStatsLocked()) return;

     ALOGV("sendGpuStats:\n"
           "\tdriverPackageName[%s]\n"
           "\tdriverVersionName[%s]\n"
           "\tdriverVersionCode[%" PRIu64 "]\n"
           "\tdriverBuildTime[%" PRId64 "]\n"
           "\tappPackageName[%s]\n"
           "\tvulkanVersion[%d]\n"
           "\tapi[%d]\n"
           "\tisDriverLoaded[%d]\n"
           "\tdriverLoadingTime[%" PRId64 "]",
           mGpuStats.driverPackageName.c_str(), mGpuStats.driverVersionName.c_str(),
           mGpuStats.driverVersionCode, mGpuStats.driverBuildTime, mGpuStats.appPackageName.c_str(),
           mGpuStats.vulkanVersion, static_cast<int32_t>(api), isDriverLoaded, driverLoadingTime);

     GpuStatsInfo::Driver driver = GpuStatsInfo::Driver::NONE;
     bool isIntendedDriverLoaded = false;
     if (api == GpuStatsInfo::Api::API_GL) {
         driver = mGpuStats.glDriverToLoad;
         isIntendedDriverLoaded =
                 isDriverLoaded && (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE);
     } else {
         driver = mGpuStats.vkDriverToLoad;
         isIntendedDriverLoaded =
                 isDriverLoaded && (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE);
     }

     const sp<IGpuService> gpuService = getGpuService();
     if (gpuService) {
         gpuService->setGpuStats(mGpuStats.driverPackageName, mGpuStats.driverVersionName,
                                 mGpuStats.driverVersionCode, mGpuStats.driverBuildTime,
                                 mGpuStats.appPackageName, mGpuStats.vulkanVersion, driver,
                                 isIntendedDriverLoaded, driverLoadingTime);
     }
 }

 bool GraphicsEnv::setInjectLayersPrSetDumpable() {
     if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) {
         return false;
     }
     return true;
 }

 void* GraphicsEnv::loadLibrary(std::string name) {
     const android_dlextinfo dlextinfo = {
             .flags = ANDROID_DLEXT_USE_NAMESPACE,
             .library_namespace = getAngleNamespace(),
     };

     std::string libName = std::string("lib") + name + "_angle.so";

     void* so = android_dlopen_ext(libName.c_str(), RTLD_LOCAL | RTLD_NOW, &dlextinfo);

     if (so) {
         ALOGD("dlopen_ext from APK (%s) success at %p", libName.c_str(), so);
         return so;
     } else {
         ALOGE("dlopen_ext(\"%s\") failed: %s", libName.c_str(), dlerror());
     }

     return nullptr;
 }

 bool GraphicsEnv::checkAngleRules(void* so) {
     char manufacturer[PROPERTY_VALUE_MAX];
     char model[PROPERTY_VALUE_MAX];
     property_get("ro.product.manufacturer", manufacturer, "UNSET");
     property_get("ro.product.model", model, "UNSET");

     auto ANGLEGetFeatureSupportUtilAPIVersion =
             (fpANGLEGetFeatureSupportUtilAPIVersion)dlsym(so,
                                                           "ANGLEGetFeatureSupportUtilAPIVersion");

     if (!ANGLEGetFeatureSupportUtilAPIVersion) {
         ALOGW("Cannot find ANGLEGetFeatureSupportUtilAPIVersion function");
         return false;
     }

     // Negotiate the interface version by requesting most recent known to the platform
     unsigned int versionToUse = CURRENT_ANGLE_API_VERSION;
     if (!(ANGLEGetFeatureSupportUtilAPIVersion)(&versionToUse)) {
         ALOGW("Cannot use ANGLE feature-support library, it is older than supported by EGL, "
               "requested version %u",
               versionToUse);
         return false;
     }

     // Add and remove versions below as needed
     bool useAngle = false;
     switch (versionToUse) {
         case 2: {
             ALOGV("Using version %d of ANGLE feature-support library", versionToUse);
             void* rulesHandle = nullptr;
             int rulesVersion = 0;
             void* systemInfoHandle = nullptr;

             // Get the symbols for the feature-support-utility library:
 #define GET_SYMBOL(symbol)                                                 \
     fp##symbol symbol = (fp##symbol)dlsym(so, #symbol);                    \
     if (!symbol) {                                                         \
         ALOGW("Cannot find " #symbol " in ANGLE feature-support library"); \
         break;                                                             \
     }
             GET_SYMBOL(ANGLEAndroidParseRulesString);
             GET_SYMBOL(ANGLEGetSystemInfo);
             GET_SYMBOL(ANGLEAddDeviceInfoToSystemInfo);
             GET_SYMBOL(ANGLEShouldBeUsedForApplication);
             GET_SYMBOL(ANGLEFreeRulesHandle);
             GET_SYMBOL(ANGLEFreeSystemInfoHandle);

             // Parse the rules, obtain the SystemInfo, and evaluate the
             // application against the rules:
             if (!(ANGLEAndroidParseRulesString)(mRulesBuffer.data(), &rulesHandle, &rulesVersion)) {
                 ALOGW("ANGLE feature-support library cannot parse rules file");
                 break;
             }
             if (!(ANGLEGetSystemInfo)(&systemInfoHandle)) {
                 ALOGW("ANGLE feature-support library cannot obtain SystemInfo");
                 break;
             }
             if (!(ANGLEAddDeviceInfoToSystemInfo)(manufacturer, model, systemInfoHandle)) {
                 ALOGW("ANGLE feature-support library cannot add device info to SystemInfo");
                 break;
             }
             useAngle = (ANGLEShouldBeUsedForApplication)(rulesHandle, rulesVersion,
                                                          systemInfoHandle, mAngleAppName.c_str());
             (ANGLEFreeRulesHandle)(rulesHandle);
             (ANGLEFreeSystemInfoHandle)(systemInfoHandle);
         } break;

         default:
             ALOGW("Version %u of ANGLE feature-support library is NOT supported.", versionToUse);
     }

     ALOGV("Close temporarily-loaded ANGLE opt-in/out logic");
     return useAngle;
 }

 bool GraphicsEnv::shouldUseAngle(std::string appName) {
     if (appName != mAngleAppName) {
         // Make sure we are checking the app we were init'ed for
         ALOGE("App name does not match: expected '%s', got '%s'", mAngleAppName.c_str(),
               appName.c_str());
         return false;
     }

     return shouldUseAngle();
 }

 bool GraphicsEnv::shouldUseAngle() {
     // Make sure we are init'ed
     if (mAngleAppName.empty()) {
         ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");
         return false;
     }

     return (mUseAngle == YES) ? true : false;
 }

 void GraphicsEnv::updateUseAngle() {
     mUseAngle = NO;

     const char* ANGLE_PREFER_ANGLE = "angle";
     const char* ANGLE_PREFER_NATIVE = "native";

     if (mAngleDeveloperOptIn == ANGLE_PREFER_ANGLE) {
         ALOGV("User set \"Developer Options\" to force the use of ANGLE");
         mUseAngle = YES;
     } else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
         ALOGV("User set \"Developer Options\" to force the use of Native");
         mUseAngle = NO;
     } else {
         // The "Developer Options" value wasn't set to force the use of ANGLE.  Need to temporarily
         // load ANGLE and call the updatable opt-in/out logic:
         void* featureSo = loadLibrary("feature_support");
         if (featureSo) {
             ALOGV("loaded ANGLE's opt-in/out logic from namespace");
             mUseAngle = checkAngleRules(featureSo) ? YES : NO;
             dlclose(featureSo);
             featureSo = nullptr;
         } else {
             ALOGV("Could not load the ANGLE opt-in/out logic, cannot use ANGLE.");
         }
     }
 }

 void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,
                                const std::string developerOptIn, const int rulesFd,
                                const long rulesOffset, const long rulesLength) {
     if (mUseAngle != UNKNOWN) {
         // We've already figured out an answer for this app, so just return.
         ALOGV("Already evaluated the rules file for '%s': use ANGLE = %s", appName.c_str(),
               (mUseAngle == YES) ? "true" : "false");
         return;
     }

     ALOGV("setting ANGLE path to '%s'", path.c_str());
     mAnglePath = path;
     ALOGV("setting ANGLE app name to '%s'", appName.c_str());
     mAngleAppName = appName;
     ALOGV("setting ANGLE application opt-in to '%s'", developerOptIn.c_str());
     mAngleDeveloperOptIn = developerOptIn;

     lseek(rulesFd, rulesOffset, SEEK_SET);
     mRulesBuffer = std::vector<char>(rulesLength + 1);
     ssize_t numBytesRead = read(rulesFd, mRulesBuffer.data(), rulesLength);
     if (numBytesRead < 0) {
         ALOGE("Cannot read rules file: numBytesRead = %zd", numBytesRead);
         numBytesRead = 0;
     } else if (numBytesRead == 0) {
         ALOGW("Empty rules file");
     }
     if (numBytesRead != rulesLength) {
         ALOGW("Did not read all of the necessary bytes from the rules file."
               "expected: %ld, got: %zd",
               rulesLength, numBytesRead);
     }
     mRulesBuffer[numBytesRead] = '\0';

     // Update the current status of whether we should use ANGLE or not
     updateUseAngle();
 }

 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::getAngleAppName() {
     return mAngleAppName;
 }

 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 Game Driver namespace correctly.
 bool GraphicsEnv::linkDriverNamespaceLocked(android_namespace_t* vndkNamespace) {
     const std::string llndkLibraries = getSystemNativeLibraries(NativeLibrary::LLNDK);
     if (llndkLibraries.empty()) {
         return false;
     }
     if (!android_link_namespaces(mDriverNamespace, 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(mDriverNamespace, vndkNamespace, vndkspLibraries.c_str())) {
         ALOGE("Failed to link vndk namespace[%s]", dlerror());
         return false;
     }

     if (mSphalLibraries.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",
               mSphalLibraries.c_str());
         return false;
     }

     if (!android_link_namespaces(mDriverNamespace, sphalNamespace, mSphalLibraries.c_str())) {
         ALOGE("Failed to link sphal namespace[%s]", dlerror());
         return false;
     }

     return true;
 }

 android_namespace_t* GraphicsEnv::getDriverNamespace() {
     std::lock_guard<std::mutex> 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<IGpuService> 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("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(vndkNamespace)) {
         mDriverNamespace = nullptr;
     }

     return mDriverNamespace;
 }

 std::string GraphicsEnv::getDriverPath() const {
     return mDriverPath;
 }

 android_namespace_t* GraphicsEnv::getAngleNamespace() {
     std::lock_guard<std::mutex> lock(mNamespaceMutex);

     if (mAngleNamespace) {
         return mAngleNamespace;
     }

     if (mAnglePath.empty()) {
         ALOGV("mAnglePath is empty, not creating ANGLE namespace");
         return nullptr;
     }

     mAngleNamespace = android_create_namespace("ANGLE",
                                                nullptr,            // ld_library_path
                                                mAnglePath.c_str(), // default_library_path
                                                ANDROID_NAMESPACE_TYPE_SHARED |
                                                        ANDROID_NAMESPACE_TYPE_ISOLATED,
                                                nullptr, // permitted_when_isolated_path
                                                nullptr);

     ALOGD_IF(!mAngleNamespace, "Could not create ANGLE namespace from default");

     return mAngleNamespace;
 }

 } // namespace android
	/*
	* Copyright 2017 The Android Open Source Project
	*
	* 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.
	*/

	#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	//#define LOG_NDEBUG 1
	#define LOG_TAG "GraphicsEnv"

	#include <graphicsenv/GraphicsEnv.h>

	#include <dlfcn.h>
	#include <unistd.h>

	#include <android-base/file.h>
	#include <android-base/properties.h>
	#include <android-base/strings.h>
	#include <android/dlext.h>
	#include <binder/IServiceManager.h>
	#include <cutils/properties.h>
	#include <graphicsenv/IGpuService.h>
	#include <log/log.h>
	#include <nativeloader/dlext_namespaces.h>
	#include <sys/prctl.h>
	#include <utils/Trace.h>

	#include <memory>
	#include <string>
	#include <thread>

	// TODO(b/159240322): Extend this to x86 ABI.
	#if defined(__LP64__)
	#define UPDATABLE_DRIVER_ABI "arm64-v8a"
	#else
	#define UPDATABLE_DRIVER_ABI "armeabi-v7a"
	#endif // defined(__LP64__)

	// TODO(ianelliott@): Get the following from an ANGLE header:
	#define CURRENT_ANGLE_API_VERSION 2 // Current API verion we are targetting
	// Version-2 API:
	typedef bool (fpANGLEGetFeatureSupportUtilAPIVersion)(unsigned int versionToUse);
	typedef bool (fpANGLEAndroidParseRulesString)(const char rulesString, void** rulesHandle,
	int* rulesVersion);
	typedef bool (fpANGLEGetSystemInfo)(void* handle);
	typedef bool (fpANGLEAddDeviceInfoToSystemInfo)(const char deviceMfr, const char* deviceModel,
	void* handle);
	typedef bool (fpANGLEShouldBeUsedForApplication)(void rulesHandle, int rulesVersion,
	void* systemInfoHandle, const char* appName);
	typedef bool (fpANGLEFreeRulesHandle)(void handle);
	typedef bool (fpANGLEFreeSystemInfoHandle)(void handle);

	namespace android {

	enum NativeLibrary {
	LLNDK = 0,
	VNDKSP = 1,
	};

	static constexpr const char* kNativeLibrariesSystemConfigPath[] =
	{"/apex/com.android.vndk.v{}/etc/llndk.libraries.{}.txt",
	"/apex/com.android.vndk.v{}/etc/vndksp.libraries.{}.txt"};

	static std::string vndkVersionStr() {
	#ifdef __BIONIC__
	return android::base::GetProperty("ro.vndk.version", "");
	#endif
	return "";
	}

	static void insertVndkVersionStr(std::string* fileName) {
	LOG_ALWAYS_FATAL_IF(!fileName, "fileName should never be nullptr");
	std::string version = vndkVersionStr();
	size_t pos = fileName->find("{}");
	while (pos != std::string::npos) {
	fileName->replace(pos, 2, version);
	pos = fileName->find("{}", pos + version.size());
	}
	}

	static bool readConfig(const std::string& configFile, std::vector<std::string>* soNames) {
	// Read list of public native libraries from the config file.
	std::string fileContent;
	if (!base::ReadFileToString(configFile, &fileContent)) {
	return false;
	}

	std::vector<std::string> lines = base::Split(fileContent, "\n");

	for (auto& line : lines) {
	auto trimmedLine = base::Trim(line);
	if (!trimmedLine.empty()) {
	soNames->push_back(trimmedLine);
	}
	}

	return true;
	}

	static const std::string getSystemNativeLibraries(NativeLibrary type) {
	std::string nativeLibrariesSystemConfig = kNativeLibrariesSystemConfigPath[type];
	insertVndkVersionStr(&nativeLibrariesSystemConfig);

	std::vector<std::string> soNames;
	if (!readConfig(nativeLibrariesSystemConfig, &soNames)) {
	ALOGE("Failed to retrieve library names from %s", nativeLibrariesSystemConfig.c_str());
	return "";
	}

	return base::Join(soNames, ':');
	}

	/static/ GraphicsEnv& GraphicsEnv::getInstance() {
	static GraphicsEnv env;
	return env;
	}

	bool GraphicsEnv::isDebuggable() {
	return prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) > 0;
	}

	void GraphicsEnv::setDriverPathAndSphalLibraries(const std::string path,
	const std::string sphalLibraries) {
	if (!mDriverPath.empty() \|\| !mSphalLibraries.empty()) {
	ALOGV("ignoring attempt to change driver path from '%s' to '%s' or change sphal libraries "
	"from '%s' to '%s'",
	mDriverPath.c_str(), path.c_str(), mSphalLibraries.c_str(), sphalLibraries.c_str());
	return;
	}
	ALOGV("setting driver path to '%s' and sphal libraries to '%s'", path.c_str(),
	sphalLibraries.c_str());
	mDriverPath = path;
	mSphalLibraries = sphalLibraries;
	}

	void GraphicsEnv::hintActivityLaunch() {
	ATRACE_CALL();

	{
	std::lock_guard<std::mutex> lock(mStatsLock);
	if (mActivityLaunched) return;
	mActivityLaunched = true;
	}

	std::thread trySendGpuStatsThread([this]() {
	// If there's already graphics driver preloaded in the process, just send
	// the stats info to GpuStats directly through async binder.
	std::lock_guard<std::mutex> lock(mStatsLock);
	if (mGpuStats.glDriverToSend) {
	mGpuStats.glDriverToSend = false;
	sendGpuStatsLocked(GpuStatsInfo::Api::API_GL, true, mGpuStats.glDriverLoadingTime);
	}
	if (mGpuStats.vkDriverToSend) {
	mGpuStats.vkDriverToSend = false;
	sendGpuStatsLocked(GpuStatsInfo::Api::API_VK, true, mGpuStats.vkDriverLoadingTime);
	}
	});
	trySendGpuStatsThread.detach();
	}

	void GraphicsEnv::setGpuStats(const std::string& driverPackageName,
	const std::string& driverVersionName, uint64_t driverVersionCode,
	int64_t driverBuildTime, const std::string& appPackageName,
	const int vulkanVersion) {
	ATRACE_CALL();

	std::lock_guard<std::mutex> lock(mStatsLock);
	ALOGV("setGpuStats:\n"
	"\tdriverPackageName[%s]\n"
	"\tdriverVersionName[%s]\n"
	"\tdriverVersionCode[%" PRIu64 "]\n"
	"\tdriverBuildTime[%" PRId64 "]\n"
	"\tappPackageName[%s]\n"
	"\tvulkanVersion[%d]\n",
	driverPackageName.c_str(), driverVersionName.c_str(), driverVersionCode, driverBuildTime,
	appPackageName.c_str(), vulkanVersion);

	mGpuStats.driverPackageName = driverPackageName;
	mGpuStats.driverVersionName = driverVersionName;
	mGpuStats.driverVersionCode = driverVersionCode;
	mGpuStats.driverBuildTime = driverBuildTime;
	mGpuStats.appPackageName = appPackageName;
	mGpuStats.vulkanVersion = vulkanVersion;
	}

	void GraphicsEnv::setDriverToLoad(GpuStatsInfo::Driver driver) {
	ATRACE_CALL();

	std::lock_guard<std::mutex> lock(mStatsLock);
	switch (driver) {
	case GpuStatsInfo::Driver::GL:
	case GpuStatsInfo::Driver::GL_UPDATED:
	case GpuStatsInfo::Driver::ANGLE: {
	if (mGpuStats.glDriverToLoad == GpuStatsInfo::Driver::NONE \|\|
	mGpuStats.glDriverToLoad == GpuStatsInfo::Driver::GL) {
	mGpuStats.glDriverToLoad = driver;
	break;
	}

	if (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE) {
	mGpuStats.glDriverFallback = driver;
	}
	break;
	}
	case GpuStatsInfo::Driver::VULKAN:
	case GpuStatsInfo::Driver::VULKAN_UPDATED: {
	if (mGpuStats.vkDriverToLoad == GpuStatsInfo::Driver::NONE \|\|
	mGpuStats.vkDriverToLoad == GpuStatsInfo::Driver::VULKAN) {
	mGpuStats.vkDriverToLoad = driver;
	break;
	}

	if (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE) {
	mGpuStats.vkDriverFallback = driver;
	}
	break;
	}
	default:
	break;
	}
	}

	void GraphicsEnv::setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded,
	int64_t driverLoadingTime) {
	ATRACE_CALL();

	std::lock_guard<std::mutex> lock(mStatsLock);
	if (api == GpuStatsInfo::Api::API_GL) {
	mGpuStats.glDriverToSend = true;
	mGpuStats.glDriverLoadingTime = driverLoadingTime;
	} else {
	mGpuStats.vkDriverToSend = true;
	mGpuStats.vkDriverLoadingTime = driverLoadingTime;
	}

	sendGpuStatsLocked(api, isDriverLoaded, driverLoadingTime);
	}

	static sp<IGpuService> getGpuService() {
	static const sp<IBinder> binder = defaultServiceManager()->checkService(String16("gpu"));
	if (!binder) {
	ALOGE("Failed to get gpu service");
	return nullptr;
	}

	return interface_cast<IGpuService>(binder);
	}

	bool GraphicsEnv::readyToSendGpuStatsLocked() {
	// Only send stats for processes having at least one activity launched and that process doesn't
	// skip the GraphicsEnvironment setup.
	return mActivityLaunched && !mGpuStats.appPackageName.empty();
	}

	void GraphicsEnv::setTargetStats(const GpuStatsInfo::Stats stats, const uint64_t value) {
	ATRACE_CALL();

	std::lock_guard<std::mutex> lock(mStatsLock);
	if (!readyToSendGpuStatsLocked()) return;

	const sp<IGpuService> gpuService = getGpuService();
	if (gpuService) {
	gpuService->setTargetStats(mGpuStats.appPackageName, mGpuStats.driverVersionCode, stats,
	value);
	}
	}

	void GraphicsEnv::sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded,
	int64_t driverLoadingTime) {
	ATRACE_CALL();

	if (!readyToSendGpuStatsLocked()) return;

	ALOGV("sendGpuStats:\n"
	"\tdriverPackageName[%s]\n"
	"\tdriverVersionName[%s]\n"
	"\tdriverVersionCode[%" PRIu64 "]\n"
	"\tdriverBuildTime[%" PRId64 "]\n"
	"\tappPackageName[%s]\n"
	"\tvulkanVersion[%d]\n"
	"\tapi[%d]\n"
	"\tisDriverLoaded[%d]\n"
	"\tdriverLoadingTime[%" PRId64 "]",
	mGpuStats.driverPackageName.c_str(), mGpuStats.driverVersionName.c_str(),
	mGpuStats.driverVersionCode, mGpuStats.driverBuildTime, mGpuStats.appPackageName.c_str(),
	mGpuStats.vulkanVersion, static_cast<int32_t>(api), isDriverLoaded, driverLoadingTime);

	GpuStatsInfo::Driver driver = GpuStatsInfo::Driver::NONE;
	bool isIntendedDriverLoaded = false;
	if (api == GpuStatsInfo::Api::API_GL) {
	driver = mGpuStats.glDriverToLoad;
	isIntendedDriverLoaded =
	isDriverLoaded && (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE);
	} else {
	driver = mGpuStats.vkDriverToLoad;
	isIntendedDriverLoaded =
	isDriverLoaded && (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE);
	}

	const sp<IGpuService> gpuService = getGpuService();
	if (gpuService) {
	gpuService->setGpuStats(mGpuStats.driverPackageName, mGpuStats.driverVersionName,
	mGpuStats.driverVersionCode, mGpuStats.driverBuildTime,
	mGpuStats.appPackageName, mGpuStats.vulkanVersion, driver,
	isIntendedDriverLoaded, driverLoadingTime);
	}
	}

	bool GraphicsEnv::setInjectLayersPrSetDumpable() {
	if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) {
	return false;
	}
	return true;
	}

	void* GraphicsEnv::loadLibrary(std::string name) {
	const android_dlextinfo dlextinfo = {
	.flags = ANDROID_DLEXT_USE_NAMESPACE,
	.library_namespace = getAngleNamespace(),
	};

	std::string libName = std::string("lib") + name + "_angle.so";

	void* so = android_dlopen_ext(libName.c_str(), RTLD_LOCAL \| RTLD_NOW, &dlextinfo);

	if (so) {
	ALOGD("dlopen_ext from APK (%s) success at %p", libName.c_str(), so);
	return so;
	} else {
	ALOGE("dlopen_ext(\"%s\") failed: %s", libName.c_str(), dlerror());
	}

	return nullptr;
	}

	bool GraphicsEnv::checkAngleRules(void* so) {
	char manufacturer[PROPERTY_VALUE_MAX];
	char model[PROPERTY_VALUE_MAX];
	property_get("ro.product.manufacturer", manufacturer, "UNSET");
	property_get("ro.product.model", model, "UNSET");

	auto ANGLEGetFeatureSupportUtilAPIVersion =
	(fpANGLEGetFeatureSupportUtilAPIVersion)dlsym(so,
	"ANGLEGetFeatureSupportUtilAPIVersion");

	if (!ANGLEGetFeatureSupportUtilAPIVersion) {
	ALOGW("Cannot find ANGLEGetFeatureSupportUtilAPIVersion function");
	return false;
	}

	// Negotiate the interface version by requesting most recent known to the platform
	unsigned int versionToUse = CURRENT_ANGLE_API_VERSION;
	if (!(ANGLEGetFeatureSupportUtilAPIVersion)(&versionToUse)) {
	ALOGW("Cannot use ANGLE feature-support library, it is older than supported by EGL, "
	"requested version %u",
	versionToUse);
	return false;
	}

	// Add and remove versions below as needed
	bool useAngle = false;
	switch (versionToUse) {
	case 2: {
	ALOGV("Using version %d of ANGLE feature-support library", versionToUse);
	void* rulesHandle = nullptr;
	int rulesVersion = 0;
	void* systemInfoHandle = nullptr;

	// Get the symbols for the feature-support-utility library:
	#define GET_SYMBOL(symbol) \
	fp##symbol symbol = (fp##symbol)dlsym(so, #symbol); \
	if (!symbol) { \
	ALOGW("Cannot find " #symbol " in ANGLE feature-support library"); \
	break; \
	}
	GET_SYMBOL(ANGLEAndroidParseRulesString);
	GET_SYMBOL(ANGLEGetSystemInfo);
	GET_SYMBOL(ANGLEAddDeviceInfoToSystemInfo);
	GET_SYMBOL(ANGLEShouldBeUsedForApplication);
	GET_SYMBOL(ANGLEFreeRulesHandle);
	GET_SYMBOL(ANGLEFreeSystemInfoHandle);

	// Parse the rules, obtain the SystemInfo, and evaluate the
	// application against the rules:
	if (!(ANGLEAndroidParseRulesString)(mRulesBuffer.data(), &rulesHandle, &rulesVersion)) {
	ALOGW("ANGLE feature-support library cannot parse rules file");
	break;
	}
	if (!(ANGLEGetSystemInfo)(&systemInfoHandle)) {
	ALOGW("ANGLE feature-support library cannot obtain SystemInfo");
	break;
	}
	if (!(ANGLEAddDeviceInfoToSystemInfo)(manufacturer, model, systemInfoHandle)) {
	ALOGW("ANGLE feature-support library cannot add device info to SystemInfo");
	break;
	}
	useAngle = (ANGLEShouldBeUsedForApplication)(rulesHandle, rulesVersion,
	systemInfoHandle, mAngleAppName.c_str());
	(ANGLEFreeRulesHandle)(rulesHandle);
	(ANGLEFreeSystemInfoHandle)(systemInfoHandle);
	} break;

	default:
	ALOGW("Version %u of ANGLE feature-support library is NOT supported.", versionToUse);
	}

	ALOGV("Close temporarily-loaded ANGLE opt-in/out logic");
	return useAngle;
	}

	bool GraphicsEnv::shouldUseAngle(std::string appName) {
	if (appName != mAngleAppName) {
	// Make sure we are checking the app we were init'ed for
	ALOGE("App name does not match: expected '%s', got '%s'", mAngleAppName.c_str(),
	appName.c_str());
	return false;
	}

	return shouldUseAngle();
	}

	bool GraphicsEnv::shouldUseAngle() {
	// Make sure we are init'ed
	if (mAngleAppName.empty()) {
	ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");
	return false;
	}

	return (mUseAngle == YES) ? true : false;
	}

	void GraphicsEnv::updateUseAngle() {
	mUseAngle = NO;

	const char* ANGLE_PREFER_ANGLE = "angle";
	const char* ANGLE_PREFER_NATIVE = "native";

	if (mAngleDeveloperOptIn == ANGLE_PREFER_ANGLE) {
	ALOGV("User set \"Developer Options\" to force the use of ANGLE");
	mUseAngle = YES;
	} else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
	ALOGV("User set \"Developer Options\" to force the use of Native");
	mUseAngle = NO;
	} else {
	// The "Developer Options" value wasn't set to force the use of ANGLE. Need to temporarily
	// load ANGLE and call the updatable opt-in/out logic:
	void* featureSo = loadLibrary("feature_support");
	if (featureSo) {
	ALOGV("loaded ANGLE's opt-in/out logic from namespace");
	mUseAngle = checkAngleRules(featureSo) ? YES : NO;
	dlclose(featureSo);
	featureSo = nullptr;
	} else {
	ALOGV("Could not load the ANGLE opt-in/out logic, cannot use ANGLE.");
	}
	}
	}

	void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,
	const std::string developerOptIn, const int rulesFd,
	const long rulesOffset, const long rulesLength) {
	if (mUseAngle != UNKNOWN) {
	// We've already figured out an answer for this app, so just return.
	ALOGV("Already evaluated the rules file for '%s': use ANGLE = %s", appName.c_str(),
	(mUseAngle == YES) ? "true" : "false");
	return;
	}

	ALOGV("setting ANGLE path to '%s'", path.c_str());
	mAnglePath = path;
	ALOGV("setting ANGLE app name to '%s'", appName.c_str());
	mAngleAppName = appName;
	ALOGV("setting ANGLE application opt-in to '%s'", developerOptIn.c_str());
	mAngleDeveloperOptIn = developerOptIn;

	lseek(rulesFd, rulesOffset, SEEK_SET);
	mRulesBuffer = std::vector<char>(rulesLength + 1);
	ssize_t numBytesRead = read(rulesFd, mRulesBuffer.data(), rulesLength);
	if (numBytesRead < 0) {
	ALOGE("Cannot read rules file: numBytesRead = %zd", numBytesRead);
	numBytesRead = 0;
	} else if (numBytesRead == 0) {
	ALOGW("Empty rules file");
	}
	if (numBytesRead != rulesLength) {
	ALOGW("Did not read all of the necessary bytes from the rules file."
	"expected: %ld, got: %zd",
	rulesLength, numBytesRead);
	}
	mRulesBuffer[numBytesRead] = '\0';

	// Update the current status of whether we should use ANGLE or not
	updateUseAngle();
	}

	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::getAngleAppName() {
	return mAngleAppName;
	}

	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 Game Driver namespace correctly.
	bool GraphicsEnv::linkDriverNamespaceLocked(android_namespace_t* vndkNamespace) {
	const std::string llndkLibraries = getSystemNativeLibraries(NativeLibrary::LLNDK);
	if (llndkLibraries.empty()) {
	return false;
	}
	if (!android_link_namespaces(mDriverNamespace, 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(mDriverNamespace, vndkNamespace, vndkspLibraries.c_str())) {
	ALOGE("Failed to link vndk namespace[%s]", dlerror());
	return false;
	}

	if (mSphalLibraries.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",
	mSphalLibraries.c_str());
	return false;
	}

	if (!android_link_namespaces(mDriverNamespace, sphalNamespace, mSphalLibraries.c_str())) {
	ALOGE("Failed to link sphal namespace[%s]", dlerror());
	return false;
	}

	return true;
	}

	android_namespace_t* GraphicsEnv::getDriverNamespace() {
	std::lock_guard<std::mutex> 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<IGpuService> 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("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(vndkNamespace)) {
	mDriverNamespace = nullptr;
	}

	return mDriverNamespace;
	}

	std::string GraphicsEnv::getDriverPath() const {
	return mDriverPath;
	}

	android_namespace_t* GraphicsEnv::getAngleNamespace() {
	std::lock_guard<std::mutex> lock(mNamespaceMutex);

	if (mAngleNamespace) {
	return mAngleNamespace;
	}

	if (mAnglePath.empty()) {
	ALOGV("mAnglePath is empty, not creating ANGLE namespace");
	return nullptr;
	}

	mAngleNamespace = android_create_namespace("ANGLE",
	nullptr, // ld_library_path
	mAnglePath.c_str(), // default_library_path
	ANDROID_NAMESPACE_TYPE_SHARED \|
	ANDROID_NAMESPACE_TYPE_ISOLATED,
	nullptr, // permitted_when_isolated_path
	nullptr);

	ALOGD_IF(!mAngleNamespace, "Could not create ANGLE namespace from default");

	return mAngleNamespace;
	}

	} // namespace android