Merge "Allow native process to load updatable driver." into rvc-dev (09397229) · Commits · e / os / platform_frameworks_native

libs/graphicsenv/GraphicsEnv.cpp

+29 −1

Original line number	Original line	Diff line number	Diff line
	@@ -40,6 +40,13 @@
	#include <string>		#include <string>
	#include <thread>		#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:		// TODO(ianelliott@): Get the following from an ANGLE header:
	#define CURRENT_ANGLE_API_VERSION 2 // Current API verion we are targetting		#define CURRENT_ANGLE_API_VERSION 2 // Current API verion we are targetting
	// Version-2 API:		// Version-2 API:
	@@ -583,9 +590,30 @@ android_namespace_t* GraphicsEnv::getDriverNamespace() {
	return 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()) {		if (mDriverPath.empty()) {
	return nullptr;		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");		auto vndkNamespace = android_get_exported_namespace("vndk");
	if (!vndkNamespace) {		if (!vndkNamespace) {

libs/graphicsenv/IGpuService.cpp

+43 −7

Original line number	Original line	Diff line number	Diff line
	@@ -27,11 +27,11 @@ class BpGpuService : public BpInterface<IGpuService> {
	public:		public:
	explicit BpGpuService(const sp<IBinder>& impl) : BpInterface<IGpuService>(impl) {}		explicit BpGpuService(const sp<IBinder>& impl) : BpInterface<IGpuService>(impl) {}

	virtual void setGpuStats(const std::string& driverPackageName,		void setGpuStats(const std::string& driverPackageName, const std::string& driverVersionName,
	const std::string& driverVersionName, uint64_t driverVersionCode,		uint64_t driverVersionCode, int64_t driverBuildTime,
	int64_t driverBuildTime, const std::string& appPackageName,		const std::string& appPackageName, const int32_t vulkanVersion,
	const int32_t vulkanVersion, GpuStatsInfo::Driver driver,		GpuStatsInfo::Driver driver, bool isDriverLoaded,
	bool isDriverLoaded, int64_t driverLoadingTime) {		int64_t driverLoadingTime) override {
	Parcel data, reply;		Parcel data, reply;
	data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());		data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());

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

	virtual void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,		void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,
	const GpuStatsInfo::Stats stats, const uint64_t value) {		const GpuStatsInfo::Stats stats, const uint64_t value) override {
	Parcel data, reply;		Parcel data, reply;
	data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());		data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());

	@@ -60,6 +60,27 @@ public:

	remote()->transact(BnGpuService::SET_TARGET_STATS, data, &reply, IBinder::FLAG_ONEWAY);		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");		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;		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: {		case SHELL_COMMAND_TRANSACTION: {
	int in = data.readFileDescriptor();		int in = data.readFileDescriptor();
	int out = data.readFileDescriptor();		int out = data.readFileDescriptor();

libs/graphicsenv/include/graphicsenv/IGpuService.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -42,6 +42,10 @@ public:
	// set target stats.		// set target stats.
	virtual void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,		virtual void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,
	const GpuStatsInfo::Stats stats, const uint64_t value = 0) = 0;		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> {		class BnGpuService : public BnInterface<IGpuService> {
	@@ -49,6 +53,8 @@ public:
	enum IGpuServiceTag {		enum IGpuServiceTag {
	SET_GPU_STATS = IBinder::FIRST_CALL_TRANSACTION,		SET_GPU_STATS = IBinder::FIRST_CALL_TRANSACTION,
	SET_TARGET_STATS,		SET_TARGET_STATS,
			SET_UPDATABLE_DRIVER_PATH,
			GET_UPDATABLE_DRIVER_PATH,
	// Always append new enum to the end.		// Always append new enum to the end.
	};		};

services/gpuservice/GpuService.cpp

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -62,6 +62,14 @@ void GpuService::setTargetStats(const std::string& appPackageName, const uint64_
	mGpuStats->insertTargetStats(appPackageName, driverVersionCode, stats, value);		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) {		status_t GpuService::shellCommand(int /in/, int out, int err, std::vector<String16>& args) {
	ATRACE_CALL();		ATRACE_CALL();

services/gpuservice/GpuService.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -50,6 +50,8 @@ private:
	int64_t driverLoadingTime) override;		int64_t driverLoadingTime) override;
	void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,		void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,
	const GpuStatsInfo::Stats stats, const uint64_t value) override;		const GpuStatsInfo::Stats stats, const uint64_t value) override;
			void setUpdatableDriverPath(const std::string& driverPath) override;
			std::string getUpdatableDriverPath() override;

	/*		/*
	* IBinder interface		* IBinder interface
	@@ -73,6 +75,7 @@ private:
	* Attributes		* Attributes
	*/		*/
	std::unique_ptr<GpuStats> mGpuStats;		std::unique_ptr<GpuStats> mGpuStats;
			std::string developerDriverPath;
	};		};

	} // namespace android		} // namespace android