1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "GpuService"
18
19 #include <graphicsenv/IGpuService.h>
20
21 #include <binder/IResultReceiver.h>
22 #include <binder/Parcel.h>
23
24 namespace android {
25
26 class BpGpuService : public BpInterface<IGpuService> {
27 public:
BpGpuService(const sp<IBinder> & impl)28 explicit BpGpuService(const sp<IBinder>& impl) : BpInterface<IGpuService>(impl) {}
29
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)30 void setGpuStats(const std::string& driverPackageName, const std::string& driverVersionName,
31 uint64_t driverVersionCode, int64_t driverBuildTime,
32 const std::string& appPackageName, const int32_t vulkanVersion,
33 GpuStatsInfo::Driver driver, bool isDriverLoaded,
34 int64_t driverLoadingTime) override {
35 Parcel data, reply;
36 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
37
38 data.writeUtf8AsUtf16(driverPackageName);
39 data.writeUtf8AsUtf16(driverVersionName);
40 data.writeUint64(driverVersionCode);
41 data.writeInt64(driverBuildTime);
42 data.writeUtf8AsUtf16(appPackageName);
43 data.writeInt32(vulkanVersion);
44 data.writeInt32(static_cast<int32_t>(driver));
45 data.writeBool(isDriverLoaded);
46 data.writeInt64(driverLoadingTime);
47
48 remote()->transact(BnGpuService::SET_GPU_STATS, data, &reply, IBinder::FLAG_ONEWAY);
49 }
50
setTargetStats(const std::string & appPackageName,const uint64_t driverVersionCode,const GpuStatsInfo::Stats stats,const uint64_t value)51 void setTargetStats(const std::string& appPackageName, const uint64_t driverVersionCode,
52 const GpuStatsInfo::Stats stats, const uint64_t value) override {
53 Parcel data, reply;
54 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
55
56 data.writeUtf8AsUtf16(appPackageName);
57 data.writeUint64(driverVersionCode);
58 data.writeInt32(static_cast<int32_t>(stats));
59 data.writeUint64(value);
60
61 remote()->transact(BnGpuService::SET_TARGET_STATS, data, &reply, IBinder::FLAG_ONEWAY);
62 }
63
setTargetStatsArray(const std::string & appPackageName,const uint64_t driverVersionCode,const GpuStatsInfo::Stats stats,const uint64_t * values,const uint32_t valueCount)64 void setTargetStatsArray(const std::string& appPackageName, const uint64_t driverVersionCode,
65 const GpuStatsInfo::Stats stats, const uint64_t* values,
66 const uint32_t valueCount) override {
67 Parcel data, reply;
68 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
69
70 data.writeUtf8AsUtf16(appPackageName);
71 data.writeUint64(driverVersionCode);
72 data.writeInt32(static_cast<int32_t>(stats));
73 data.writeUint32(valueCount);
74 data.write(values, valueCount * sizeof(uint64_t));
75
76 remote()->transact(BnGpuService::SET_TARGET_STATS_ARRAY, data, &reply,
77 IBinder::FLAG_ONEWAY);
78 }
79
addVulkanEngineName(const std::string & appPackageName,const uint64_t driverVersionCode,const char * engineName)80 void addVulkanEngineName(const std::string& appPackageName, const uint64_t driverVersionCode,
81 const char* engineName) override {
82 Parcel data, reply;
83 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
84
85 data.writeUtf8AsUtf16(appPackageName);
86 data.writeUint64(driverVersionCode);
87 data.writeCString(engineName);
88
89 remote()->transact(BnGpuService::ADD_VULKAN_ENGINE_NAME, data, &reply,
90 IBinder::FLAG_ONEWAY);
91 }
92
setUpdatableDriverPath(const std::string & driverPath)93 void setUpdatableDriverPath(const std::string& driverPath) override {
94 Parcel data, reply;
95 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
96 data.writeUtf8AsUtf16(driverPath);
97
98 remote()->transact(BnGpuService::SET_UPDATABLE_DRIVER_PATH, data, &reply,
99 IBinder::FLAG_ONEWAY);
100 }
101
toggleAngleAsSystemDriver(bool enabled)102 void toggleAngleAsSystemDriver(bool enabled) override {
103 Parcel data, reply;
104 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
105 data.writeBool(enabled);
106
107 remote()->transact(BnGpuService::TOGGLE_ANGLE_AS_SYSTEM_DRIVER, data, &reply,
108 IBinder::FLAG_ONEWAY);
109 }
110
getUpdatableDriverPath()111 std::string getUpdatableDriverPath() override {
112 Parcel data, reply;
113 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
114
115 status_t error = remote()->transact(BnGpuService::GET_UPDATABLE_DRIVER_PATH, data, &reply);
116 std::string driverPath;
117 if (error == OK) {
118 error = reply.readUtf8FromUtf16(&driverPath);
119 }
120 return driverPath;
121 }
122
getFeatureOverrides()123 FeatureOverrides getFeatureOverrides() override {
124 Parcel data, reply;
125 data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
126
127 FeatureOverrides featureOverrides;
128 status_t error =
129 remote()->transact(BnGpuService::GET_FEATURE_CONFIG_OVERRIDES, data, &reply);
130 if (error != OK) {
131 return featureOverrides;
132 }
133
134 featureOverrides.readFromParcel(&reply);
135 return featureOverrides;
136 }
137 };
138
139 IMPLEMENT_META_INTERFACE(GpuService, "android.graphicsenv.IGpuService");
140
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)141 status_t BnGpuService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
142 uint32_t flags) {
143 ALOGV("onTransact code[0x%X]", code);
144
145 status_t status;
146 switch (code) {
147 case SET_GPU_STATS: {
148 CHECK_INTERFACE(IGpuService, data, reply);
149
150 std::string driverPackageName;
151 if ((status = data.readUtf8FromUtf16(&driverPackageName)) != OK) return status;
152
153 std::string driverVersionName;
154 if ((status = data.readUtf8FromUtf16(&driverVersionName)) != OK) return status;
155
156 uint64_t driverVersionCode;
157 if ((status = data.readUint64(&driverVersionCode)) != OK) return status;
158
159 int64_t driverBuildTime;
160 if ((status = data.readInt64(&driverBuildTime)) != OK) return status;
161
162 std::string appPackageName;
163 if ((status = data.readUtf8FromUtf16(&appPackageName)) != OK) return status;
164
165 int32_t vulkanVersion;
166 if ((status = data.readInt32(&vulkanVersion)) != OK) return status;
167
168 int32_t driver;
169 if ((status = data.readInt32(&driver)) != OK) return status;
170
171 bool isDriverLoaded;
172 if ((status = data.readBool(&isDriverLoaded)) != OK) return status;
173
174 int64_t driverLoadingTime;
175 if ((status = data.readInt64(&driverLoadingTime)) != OK) return status;
176
177 setGpuStats(driverPackageName, driverVersionName, driverVersionCode, driverBuildTime,
178 appPackageName, vulkanVersion, static_cast<GpuStatsInfo::Driver>(driver),
179 isDriverLoaded, driverLoadingTime);
180
181 return OK;
182 }
183 case SET_TARGET_STATS: {
184 CHECK_INTERFACE(IGpuService, data, reply);
185
186 std::string appPackageName;
187 if ((status = data.readUtf8FromUtf16(&appPackageName)) != OK) return status;
188
189 uint64_t driverVersionCode;
190 if ((status = data.readUint64(&driverVersionCode)) != OK) return status;
191
192 int32_t stats;
193 if ((status = data.readInt32(&stats)) != OK) return status;
194
195 uint64_t value;
196 if ((status = data.readUint64(&value)) != OK) return status;
197
198 setTargetStats(appPackageName, driverVersionCode,
199 static_cast<GpuStatsInfo::Stats>(stats), value);
200
201 return OK;
202 }
203 case SET_TARGET_STATS_ARRAY: {
204 CHECK_INTERFACE(IGpuService, data, reply);
205
206 std::string appPackageName;
207 if ((status = data.readUtf8FromUtf16(&appPackageName)) != OK) return status;
208
209 uint64_t driverVersionCode;
210 if ((status = data.readUint64(&driverVersionCode)) != OK) return status;
211
212 int32_t stats;
213 if ((status = data.readInt32(&stats)) != OK) return status;
214
215 uint32_t valueCount;
216 if ((status = data.readUint32(&valueCount)) != OK) return status;
217
218 std::vector<uint64_t> values(valueCount);
219 if ((status = data.read(values.data(), valueCount * sizeof(uint64_t))) != OK) {
220 return status;
221 }
222
223 setTargetStatsArray(appPackageName, driverVersionCode,
224 static_cast<GpuStatsInfo::Stats>(stats), values.data(), valueCount);
225
226 return OK;
227 }
228 case ADD_VULKAN_ENGINE_NAME: {
229 CHECK_INTERFACE(IGpuService, data, reply);
230
231 std::string appPackageName;
232 if ((status = data.readUtf8FromUtf16(&appPackageName)) != OK) return status;
233
234 uint64_t driverVersionCode;
235 if ((status = data.readUint64(&driverVersionCode)) != OK) return status;
236
237 const char* engineName;
238 if ((engineName = data.readCString()) == nullptr) return BAD_VALUE;
239
240 addVulkanEngineName(appPackageName, driverVersionCode, engineName);
241 return OK;
242 }
243 case SET_UPDATABLE_DRIVER_PATH: {
244 CHECK_INTERFACE(IGpuService, data, reply);
245
246 std::string driverPath;
247 if ((status = data.readUtf8FromUtf16(&driverPath)) != OK) return status;
248
249 setUpdatableDriverPath(driverPath);
250 return OK;
251 }
252 case GET_UPDATABLE_DRIVER_PATH: {
253 CHECK_INTERFACE(IGpuService, data, reply);
254
255 std::string driverPath = getUpdatableDriverPath();
256 return reply->writeUtf8AsUtf16(driverPath);
257 }
258 case SHELL_COMMAND_TRANSACTION: {
259 int in = dup(data.readFileDescriptor());
260 int out = dup(data.readFileDescriptor());
261 int err = dup(data.readFileDescriptor());
262
263 std::vector<String16> args;
264 data.readString16Vector(&args);
265
266 sp<IBinder> unusedCallback;
267 if ((status = data.readNullableStrongBinder(&unusedCallback)) != OK) return status;
268
269 sp<IResultReceiver> resultReceiver;
270 if ((status = data.readNullableStrongBinder(&resultReceiver)) != OK) return status;
271
272 status = shellCommand(in, out, err, args);
273 if (resultReceiver != nullptr) resultReceiver->send(status);
274 ::close(in);
275 ::close(out);
276 ::close(err);
277
278 return OK;
279 }
280 case TOGGLE_ANGLE_AS_SYSTEM_DRIVER: {
281 CHECK_INTERFACE(IGpuService, data, reply);
282
283 bool enableAngleAsSystemDriver;
284 if ((status = data.readBool(&enableAngleAsSystemDriver)) != OK) return status;
285
286 toggleAngleAsSystemDriver(enableAngleAsSystemDriver);
287 return OK;
288 }
289 case GET_FEATURE_CONFIG_OVERRIDES: {
290 CHECK_INTERFACE(IGpuService, data, reply);
291
292 // Get the FeatureOverrides from gpuservice, which implements the IGpuService interface
293 // with GpuService::getFeatureOverrides().
294 FeatureOverrides featureOverrides = getFeatureOverrides();
295 featureOverrides.writeToParcel(reply);
296 return OK;
297 }
298 default:
299 return BBinder::onTransact(code, data, reply, flags);
300 }
301 }
302
303 } // namespace android
304