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

Commit 6b388254 authored by Peiyong Lin's avatar Peiyong Lin
Browse files

Allow native process to load updatable driver. 

Previously an application process can be specified to load the updatable
driver and the driver path will be set up correctly via
GraphicsEnvironment.java.  For a native process that is not an
application process, there's no way for it to be specificed to load the
updatable driver and hence the driver path is not set up. This patch
provides a way for a native process that runs in an environment, for
example shell, where environment variables can be set, to opt into using
udpatable driver by setting UPDATABLE_GFX_DRIVER to 1.

Bug: b/157832445, b/159240322
Test: ./gapit validate_gpu_profiling --os android
Change-Id: I597535caa5ae0a033c2b8d581bb39b14875ac8fc
Merged-In: I597535caa5ae0a033c2b8d581bb39b14875ac8fc
parent 0cc0df1e

libs/graphicsenv/GraphicsEnv.cpp

+29 −1
Original line number Diff line number Diff line
@@ -40,6 +40,13 @@ 
#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:
@@ -583,9 +590,30 @@ android_namespace_t* GraphicsEnv::getDriverNamespace() { 
        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) {

libs/graphicsenv/IGpuService.cpp

+43 −7
Original line number Diff line number Diff line
@@ -27,11 +27,11 @@ class BpGpuService : public BpInterface<IGpuService> { 
public:

    explicit BpGpuService(const sp<IBinder>& impl) : BpInterface<IGpuService>(impl) {}



    virtual void setGpuStats(const std::string& driverPackageName,

                             const std::string& driverVersionName, uint64_t driverVersionCode,

                             int64_t driverBuildTime, const std::string& appPackageName,

                             const int32_t vulkanVersion, GpuStatsInfo::Driver driver,

                             bool isDriverLoaded, int64_t driverLoadingTime) {

    void setGpuStats(const std::string& driverPackageName, const std::string& driverVersionName,

                     uint64_t driverVersionCode, int64_t driverBuildTime,

                     const std::string& appPackageName, const int32_t vulkanVersion,

                     GpuStatsInfo::Driver driver, bool isDriverLoaded,

                     int64_t driverLoadingTime) override {

        Parcel data, reply;

        data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
@@ -48,8 +48,8 @@ public: 
        remote()->transact(BnGpuService::SET_GPU_STATS, data, &reply, IBinder::FLAG_ONEWAY);

    }



    virtual void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,

                                const GpuStatsInfo::Stats stats, const uint64_t value) {

    void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,

                        const GpuStatsInfo::Stats stats, const uint64_t value) override {

        Parcel data, reply;

        data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
@@ -60,6 +60,27 @@ public: 


        remote()->transact(BnGpuService::SET_TARGET_STATS, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void setUpdatableDriverPath(const std::string& driverPath) override {

        Parcel data, reply;

        data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());

        data.writeUtf8AsUtf16(driverPath);



        remote()->transact(BnGpuService::SET_UPDATABLE_DRIVER_PATH, data, &reply,

                           IBinder::FLAG_ONEWAY);

    }



    std::string getUpdatableDriverPath() override {

        Parcel data, reply;

        data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());



        status_t error = remote()->transact(BnGpuService::GET_UPDATABLE_DRIVER_PATH, data, &reply);

        std::string driverPath;

        if (error == OK) {

            error = reply.readUtf8FromUtf16(&driverPath);

        }

        return driverPath;

    }

};



IMPLEMENT_META_INTERFACE(GpuService, "android.graphicsenv.IGpuService");
@@ -126,6 +147,21 @@ status_t BnGpuService::onTransact(uint32_t code, const Parcel& data, Parcel* rep 


            return OK;

        }

        case SET_UPDATABLE_DRIVER_PATH: {

            CHECK_INTERFACE(IGpuService, data, reply);



            std::string driverPath;

            if ((status = data.readUtf8FromUtf16(&driverPath)) != OK) return status;



            setUpdatableDriverPath(driverPath);

            return OK;

        }

        case GET_UPDATABLE_DRIVER_PATH: {

            CHECK_INTERFACE(IGpuService, data, reply);



            std::string driverPath = getUpdatableDriverPath();

            return reply->writeUtf8AsUtf16(driverPath);

        }

        case SHELL_COMMAND_TRANSACTION: {

            int in = data.readFileDescriptor();

            int out = data.readFileDescriptor();

libs/graphicsenv/include/graphicsenv/IGpuService.h

+6 −0
Original line number Diff line number Diff line
@@ -42,6 +42,10 @@ public: 
    // set target stats.

    virtual void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,

                                const GpuStatsInfo::Stats stats, const uint64_t value = 0) = 0;



    // setter and getter for updatable driver path.

    virtual void setUpdatableDriverPath(const std::string& driverPath) = 0;

    virtual std::string getUpdatableDriverPath() = 0;

};



class BnGpuService : public BnInterface<IGpuService> {
@@ -49,6 +53,8 @@ public: 
    enum IGpuServiceTag {

        SET_GPU_STATS = IBinder::FIRST_CALL_TRANSACTION,

        SET_TARGET_STATS,

        SET_UPDATABLE_DRIVER_PATH,

        GET_UPDATABLE_DRIVER_PATH,

        // Always append new enum to the end.

    };

services/gpuservice/GpuService.cpp

+8 −0
Original line number Diff line number Diff line
@@ -62,6 +62,14 @@ void GpuService::setTargetStats(const std::string& appPackageName, const uint64_ 
    mGpuStats->insertTargetStats(appPackageName, driverVersionCode, stats, value);

}



void GpuService::setUpdatableDriverPath(const std::string& driverPath) {

    developerDriverPath = driverPath;

}



std::string GpuService::getUpdatableDriverPath() {

    return developerDriverPath;

}



status_t GpuService::shellCommand(int /*in*/, int out, int err, std::vector<String16>& args) {

    ATRACE_CALL();

services/gpuservice/GpuService.h

+3 −0
Original line number Diff line number Diff line
@@ -50,6 +50,8 @@ private: 
                     int64_t driverLoadingTime) override;

    void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,

                        const GpuStatsInfo::Stats stats, const uint64_t value) override;

    void setUpdatableDriverPath(const std::string& driverPath) override;

    std::string getUpdatableDriverPath() override;



    /*

     * IBinder interface
@@ -73,6 +75,7 @@ private: 
     * Attributes

     */

    std::unique_ptr<GpuStats> mGpuStats;

    std::string developerDriverPath;

};



} // namespace android