Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4240670c authored by Yiwei Zhang's avatar Yiwei Zhang Committed by Tanmay Patil
Browse files

Vulkan: load built-in driver into default namespace as a fallback 

There isn't sphal in vendor config because the default has the same
access there. This change allows vendor processes to load Vulkan driver
into the default namespace.

Bug: 170258171
Test: Vulkan driver can be loaded into vendor processes
(cherry picked from commit ecf8a24fc10398afc8bbec6e94bab25fc605fb4d)

Merged-In: If58493e6954e4e8d2309aaca392fcdffea9c6b9a
Change-Id: I96efd5234fdcdac3bfcd48b1c3f1eb309db1bb00
parent 6852ca9c

vulkan/libvulkan/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -90,7 +90,6 @@ cc_library_shared { 
        "libhardware",

        "libsync",

        "libbase",

        "libdl_android",

        "libhidlbase",

        "liblog",

        "libui",
@@ -101,6 +100,7 @@ cc_library_shared { 
        "libnativebridge_lazy",

        "libnativeloader_lazy",

        "libnativewindow",

        "libvndksupport",

        "android.hardware.graphics.common@1.0",

        "libSurfaceFlingerProp",

    ],

vulkan/libvulkan/driver.cpp

+26 −34
Original line number Diff line number Diff line
@@ -28,20 +28,17 @@ 
#include <android/dlext.h>

#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>

#include <configstore/Utils.h>

#include <cutils/properties.h>

#include <graphicsenv/GraphicsEnv.h>

#include <log/log.h>

#include <nativeloader/dlext_namespaces.h>

#include <sys/prctl.h>

#include <utils/Timers.h>

#include <utils/Trace.h>

#include <vndksupport/linker.h>



#include <algorithm>

#include <array>

#include <climits>

#include <new>

#include <string_view>

#include <sstream>

#include <vector>



#include "stubhal.h"
@@ -151,19 +148,11 @@ class CreateInfoWrapper { 


Hal Hal::hal_;



void* LoadLibrary(const android_dlextinfo& dlextinfo,

                  const std::string_view subname) {

    ATRACE_CALL();



    std::stringstream ss;

    ss << "vulkan." << subname << ".so";

    return android_dlopen_ext(ss.str().c_str(), RTLD_LOCAL | RTLD_NOW, &dlextinfo);

}



const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{

    "ro.hardware.vulkan",

    "ro.board.platform",

    "ro.hardware." HWVULKAN_HARDWARE_MODULE_ID,

    "ro.board.platform"

}};

constexpr int LIB_DL_FLAGS = RTLD_LOCAL | RTLD_NOW;



// LoadDriver returns:

// * 0 when succeed, or
@@ -174,23 +163,30 @@ int LoadDriver(android_namespace_t* library_namespace, 
               const hwvulkan_module_t** module) {

    ATRACE_CALL();



    void* so = nullptr;

    for (auto key : HAL_SUBNAME_KEY_PROPERTIES) {

        std::string lib_name = android::base::GetProperty(key, "");

        if (lib_name.empty())

            continue;



        lib_name = "vulkan." + lib_name + ".so";

        if (library_namespace) {

            // load updated driver

            const android_dlextinfo dlextinfo = {

                .flags = ANDROID_DLEXT_USE_NAMESPACE,

                .library_namespace = library_namespace,

            };

    void* so = nullptr;

    char prop[PROPERTY_VALUE_MAX];

    for (auto key : HAL_SUBNAME_KEY_PROPERTIES) {

        int prop_len = property_get(key, prop, nullptr);

        if (prop_len > 0 && prop_len <= UINT_MAX) {

            std::string_view lib_name(prop, static_cast<unsigned int>(prop_len));

            so = LoadLibrary(dlextinfo, lib_name);

            so = android_dlopen_ext(lib_name.c_str(), LIB_DL_FLAGS, &dlextinfo);

        } else {

            // load built-in driver

            so = android_load_sphal_library(lib_name.c_str(), LIB_DL_FLAGS);

        }

        if (so)

            break;

    }

    }

    if (!so)

    if (!so) {

        return -ENOENT;

    }



    auto hmi = static_cast<hw_module_t*>(dlsym(so, HAL_MODULE_INFO_SYM_AS_STR));

    if (!hmi) {
@@ -211,12 +207,9 @@ int LoadDriver(android_namespace_t* library_namespace, 
int LoadBuiltinDriver(const hwvulkan_module_t** module) {

    ATRACE_CALL();



    auto ns = android_get_exported_namespace("sphal");

    if (!ns)

        return -ENOENT;

    android::GraphicsEnv::getInstance().setDriverToLoad(

        android::GpuStatsInfo::Driver::VULKAN);

    return LoadDriver(ns, module);

    return LoadDriver(nullptr, module);

}



int LoadUpdatedDriver(const hwvulkan_module_t** module) {
@@ -238,7 +231,6 @@ int LoadUpdatedDriver(const hwvulkan_module_t** module) { 


bool Hal::Open() {

    ATRACE_CALL();



    const nsecs_t openTime = systemTime();



    ALOG_ASSERT(!hal_.dev_, "OpenHAL called more than once");
@@ -256,16 +248,16 @@ bool Hal::Open() { 
    if (result != 0) {

        android::GraphicsEnv::getInstance().setDriverLoaded(

            android::GpuStatsInfo::Api::API_VK, false, systemTime() - openTime);

        ALOGV("unable to load Vulkan HAL, using stub HAL (result=%d)", result);

        return true;

    }





    hwvulkan_device_t* device;

    ATRACE_BEGIN("hwvulkan module open");

    result =

        module->common.methods->open(&module->common, HWVULKAN_DEVICE_0,

                                     reinterpret_cast<hw_device_t**>(&device));





    ATRACE_END();

    if (result != 0) {

        android::GraphicsEnv::getInstance().setDriverLoaded(