1 #include "android/hardware/tests/memory/1.0/MemoryTest.vts.h"
2 #include <cutils/properties.h>
3 #include <cutils/properties.h>
4 #include <android/hidl/memory/1.0/IMemory.h>
5 #include <hidlmemory/mapping.h>
6
7 using namespace android::hardware::tests::memory::V1_0;
8 using namespace android::hardware;
9
10 #define TRACEFILEPREFIX "/data/local/tmp/"
11
12 namespace android {
13 namespace vts {
14
HIDL_INSTRUMENTATION_FUNCTION_android_hardware_tests_memory_V1_0_IMemoryTest(details::HidlInstrumentor::InstrumentationEvent event,const char * package,const char * version,const char * interface,const char * method,std::vector<void * > * args)15 void HIDL_INSTRUMENTATION_FUNCTION_android_hardware_tests_memory_V1_0_IMemoryTest(
16 details::HidlInstrumentor::InstrumentationEvent event __attribute__((__unused__)),
17 const char* package,
18 const char* version,
19 const char* interface,
20 const char* method __attribute__((__unused__)),
21 std::vector<void *> *args __attribute__((__unused__))) {
22 if (strcmp(package, "android.hardware.tests.memory") != 0) {
23 LOG(WARNING) << "incorrect package. Expect: android.hardware.tests.memory actual: " << package;
24 }
25 std::string version_str = std::string(version);
26 int major_version = stoi(version_str.substr(0, version_str.find('.')));
27 int minor_version = stoi(version_str.substr(version_str.find('.') + 1));
28 if (major_version != 1 || minor_version > 0) {
29 LOG(WARNING) << "incorrect version. Expect: 1.0 or lower (if version != x.0), actual: " << version;
30 }
31 if (strcmp(interface, "IMemoryTest") != 0) {
32 LOG(WARNING) << "incorrect interface. Expect: IMemoryTest actual: " << interface;
33 }
34
35 VtsProfilingInterface& profiler = VtsProfilingInterface::getInstance(TRACEFILEPREFIX);
36
37 bool profiling_for_args = property_get_bool("hal.instrumentation.profile.args", true);
38 if (strcmp(method, "haveSomeMemory") == 0) {
39 FunctionSpecificationMessage msg;
40 msg.set_name("haveSomeMemory");
41 if (profiling_for_args) {
42 if (!args) {
43 LOG(WARNING) << "no argument passed";
44 } else {
45 switch (event) {
46 case details::HidlInstrumentor::CLIENT_API_ENTRY:
47 case details::HidlInstrumentor::SERVER_API_ENTRY:
48 case details::HidlInstrumentor::PASSTHROUGH_ENTRY:
49 {
50 if ((*args).size() != 1) {
51 LOG(ERROR) << "Number of arguments does not match. expect: 1, actual: " << (*args).size() << ", method name: haveSomeMemory, event type: " << event;
52 break;
53 }
54 auto *arg_0 __attribute__((__unused__)) = msg.add_arg();
55 ::android::hardware::hidl_memory *arg_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hardware::hidl_memory*> ((*args)[0]);
56 if (arg_val_0 != nullptr) {
57 arg_0->set_type(TYPE_HIDL_MEMORY);
58 arg_0->mutable_hidl_memory_value()->set_size((*arg_val_0).size());
59 if (property_get_bool("hal.instrumentation.dump.memory", false)){
60 sp<android::hidl::memory::V1_0::IMemory> arg_0_mem = mapMemory((*arg_val_0));
61 if (arg_0_mem == nullptr) {
62 LOG(WARNING) << "Unable to map hidl_memory to IMemory object.";
63 } else {
64 arg_0_mem->read();
65 char* arg_0_mem_char = static_cast<char*>(static_cast<void*>(arg_0_mem->getPointer()));
66 arg_0->mutable_hidl_memory_value()->set_contents(string(arg_0_mem_char, (*arg_val_0).size()));
67 arg_0_mem->commit();
68 }
69 }
70 } else {
71 LOG(WARNING) << "argument 0 is null.";
72 }
73 break;
74 }
75 case details::HidlInstrumentor::CLIENT_API_EXIT:
76 case details::HidlInstrumentor::SERVER_API_EXIT:
77 case details::HidlInstrumentor::PASSTHROUGH_EXIT:
78 {
79 if ((*args).size() != 1) {
80 LOG(ERROR) << "Number of return values does not match. expect: 1, actual: " << (*args).size() << ", method name: haveSomeMemory, event type: " << event;
81 break;
82 }
83 auto *result_0 __attribute__((__unused__)) = msg.add_return_type_hidl();
84 ::android::hardware::hidl_memory *result_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hardware::hidl_memory*> ((*args)[0]);
85 if (result_val_0 != nullptr) {
86 result_0->set_type(TYPE_HIDL_MEMORY);
87 result_0->mutable_hidl_memory_value()->set_size((*result_val_0).size());
88 if (property_get_bool("hal.instrumentation.dump.memory", false)){
89 sp<android::hidl::memory::V1_0::IMemory> result_0_mem = mapMemory((*result_val_0));
90 if (result_0_mem == nullptr) {
91 LOG(WARNING) << "Unable to map hidl_memory to IMemory object.";
92 } else {
93 result_0_mem->read();
94 char* result_0_mem_char = static_cast<char*>(static_cast<void*>(result_0_mem->getPointer()));
95 result_0->mutable_hidl_memory_value()->set_contents(string(result_0_mem_char, (*result_val_0).size()));
96 result_0_mem->commit();
97 }
98 }
99 } else {
100 LOG(WARNING) << "return value 0 is null.";
101 }
102 break;
103 }
104 default:
105 {
106 LOG(WARNING) << "not supported. ";
107 break;
108 }
109 }
110 }
111 }
112 profiler.AddTraceEvent(event, package, version, interface, msg);
113 }
114 if (strcmp(method, "fillMemory") == 0) {
115 FunctionSpecificationMessage msg;
116 msg.set_name("fillMemory");
117 if (profiling_for_args) {
118 if (!args) {
119 LOG(WARNING) << "no argument passed";
120 } else {
121 switch (event) {
122 case details::HidlInstrumentor::CLIENT_API_ENTRY:
123 case details::HidlInstrumentor::SERVER_API_ENTRY:
124 case details::HidlInstrumentor::PASSTHROUGH_ENTRY:
125 {
126 if ((*args).size() != 2) {
127 LOG(ERROR) << "Number of arguments does not match. expect: 2, actual: " << (*args).size() << ", method name: fillMemory, event type: " << event;
128 break;
129 }
130 auto *arg_0 __attribute__((__unused__)) = msg.add_arg();
131 ::android::hardware::hidl_memory *arg_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hardware::hidl_memory*> ((*args)[0]);
132 if (arg_val_0 != nullptr) {
133 arg_0->set_type(TYPE_HIDL_MEMORY);
134 arg_0->mutable_hidl_memory_value()->set_size((*arg_val_0).size());
135 if (property_get_bool("hal.instrumentation.dump.memory", false)){
136 sp<android::hidl::memory::V1_0::IMemory> arg_0_mem = mapMemory((*arg_val_0));
137 if (arg_0_mem == nullptr) {
138 LOG(WARNING) << "Unable to map hidl_memory to IMemory object.";
139 } else {
140 arg_0_mem->read();
141 char* arg_0_mem_char = static_cast<char*>(static_cast<void*>(arg_0_mem->getPointer()));
142 arg_0->mutable_hidl_memory_value()->set_contents(string(arg_0_mem_char, (*arg_val_0).size()));
143 arg_0_mem->commit();
144 }
145 }
146 } else {
147 LOG(WARNING) << "argument 0 is null.";
148 }
149 auto *arg_1 __attribute__((__unused__)) = msg.add_arg();
150 uint8_t *arg_val_1 __attribute__((__unused__)) = reinterpret_cast<uint8_t*> ((*args)[1]);
151 if (arg_val_1 != nullptr) {
152 arg_1->set_type(TYPE_SCALAR);
153 arg_1->mutable_scalar_value()->set_uint8_t((*arg_val_1));
154 } else {
155 LOG(WARNING) << "argument 1 is null.";
156 }
157 break;
158 }
159 case details::HidlInstrumentor::CLIENT_API_EXIT:
160 case details::HidlInstrumentor::SERVER_API_EXIT:
161 case details::HidlInstrumentor::PASSTHROUGH_EXIT:
162 {
163 if ((*args).size() != 0) {
164 LOG(ERROR) << "Number of return values does not match. expect: 0, actual: " << (*args).size() << ", method name: fillMemory, event type: " << event;
165 break;
166 }
167 break;
168 }
169 default:
170 {
171 LOG(WARNING) << "not supported. ";
172 break;
173 }
174 }
175 }
176 }
177 profiler.AddTraceEvent(event, package, version, interface, msg);
178 }
179 if (strcmp(method, "haveSomeMemoryBlock") == 0) {
180 FunctionSpecificationMessage msg;
181 msg.set_name("haveSomeMemoryBlock");
182 if (profiling_for_args) {
183 if (!args) {
184 LOG(WARNING) << "no argument passed";
185 } else {
186 switch (event) {
187 case details::HidlInstrumentor::CLIENT_API_ENTRY:
188 case details::HidlInstrumentor::SERVER_API_ENTRY:
189 case details::HidlInstrumentor::PASSTHROUGH_ENTRY:
190 {
191 if ((*args).size() != 1) {
192 LOG(ERROR) << "Number of arguments does not match. expect: 1, actual: " << (*args).size() << ", method name: haveSomeMemoryBlock, event type: " << event;
193 break;
194 }
195 auto *arg_0 __attribute__((__unused__)) = msg.add_arg();
196 ::android::hidl::memory::block::V1_0::MemoryBlock *arg_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hidl::memory::block::V1_0::MemoryBlock*> ((*args)[0]);
197 if (arg_val_0 != nullptr) {
198 arg_0->set_type(TYPE_STRUCT);
199 profile____android__hidl__memory__block__V1_0__MemoryBlock(arg_0, (*arg_val_0));
200 } else {
201 LOG(WARNING) << "argument 0 is null.";
202 }
203 break;
204 }
205 case details::HidlInstrumentor::CLIENT_API_EXIT:
206 case details::HidlInstrumentor::SERVER_API_EXIT:
207 case details::HidlInstrumentor::PASSTHROUGH_EXIT:
208 {
209 if ((*args).size() != 1) {
210 LOG(ERROR) << "Number of return values does not match. expect: 1, actual: " << (*args).size() << ", method name: haveSomeMemoryBlock, event type: " << event;
211 break;
212 }
213 auto *result_0 __attribute__((__unused__)) = msg.add_return_type_hidl();
214 ::android::hidl::memory::block::V1_0::MemoryBlock *result_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hidl::memory::block::V1_0::MemoryBlock*> ((*args)[0]);
215 if (result_val_0 != nullptr) {
216 result_0->set_type(TYPE_STRUCT);
217 profile____android__hidl__memory__block__V1_0__MemoryBlock(result_0, (*result_val_0));
218 } else {
219 LOG(WARNING) << "return value 0 is null.";
220 }
221 break;
222 }
223 default:
224 {
225 LOG(WARNING) << "not supported. ";
226 break;
227 }
228 }
229 }
230 }
231 profiler.AddTraceEvent(event, package, version, interface, msg);
232 }
233 if (strcmp(method, "set") == 0) {
234 FunctionSpecificationMessage msg;
235 msg.set_name("set");
236 if (profiling_for_args) {
237 if (!args) {
238 LOG(WARNING) << "no argument passed";
239 } else {
240 switch (event) {
241 case details::HidlInstrumentor::CLIENT_API_ENTRY:
242 case details::HidlInstrumentor::SERVER_API_ENTRY:
243 case details::HidlInstrumentor::PASSTHROUGH_ENTRY:
244 {
245 if ((*args).size() != 1) {
246 LOG(ERROR) << "Number of arguments does not match. expect: 1, actual: " << (*args).size() << ", method name: set, event type: " << event;
247 break;
248 }
249 auto *arg_0 __attribute__((__unused__)) = msg.add_arg();
250 ::android::hardware::hidl_memory *arg_val_0 __attribute__((__unused__)) = reinterpret_cast<::android::hardware::hidl_memory*> ((*args)[0]);
251 if (arg_val_0 != nullptr) {
252 arg_0->set_type(TYPE_HIDL_MEMORY);
253 arg_0->mutable_hidl_memory_value()->set_size((*arg_val_0).size());
254 if (property_get_bool("hal.instrumentation.dump.memory", false)){
255 sp<android::hidl::memory::V1_0::IMemory> arg_0_mem = mapMemory((*arg_val_0));
256 if (arg_0_mem == nullptr) {
257 LOG(WARNING) << "Unable to map hidl_memory to IMemory object.";
258 } else {
259 arg_0_mem->read();
260 char* arg_0_mem_char = static_cast<char*>(static_cast<void*>(arg_0_mem->getPointer()));
261 arg_0->mutable_hidl_memory_value()->set_contents(string(arg_0_mem_char, (*arg_val_0).size()));
262 arg_0_mem->commit();
263 }
264 }
265 } else {
266 LOG(WARNING) << "argument 0 is null.";
267 }
268 break;
269 }
270 case details::HidlInstrumentor::CLIENT_API_EXIT:
271 case details::HidlInstrumentor::SERVER_API_EXIT:
272 case details::HidlInstrumentor::PASSTHROUGH_EXIT:
273 {
274 if ((*args).size() != 0) {
275 LOG(ERROR) << "Number of return values does not match. expect: 0, actual: " << (*args).size() << ", method name: set, event type: " << event;
276 break;
277 }
278 break;
279 }
280 default:
281 {
282 LOG(WARNING) << "not supported. ";
283 break;
284 }
285 }
286 }
287 }
288 profiler.AddTraceEvent(event, package, version, interface, msg);
289 }
290 if (strcmp(method, "get") == 0) {
291 FunctionSpecificationMessage msg;
292 msg.set_name("get");
293 if (profiling_for_args) {
294 if (!args) {
295 LOG(WARNING) << "no argument passed";
296 } else {
297 switch (event) {
298 case details::HidlInstrumentor::CLIENT_API_ENTRY:
299 case details::HidlInstrumentor::SERVER_API_ENTRY:
300 case details::HidlInstrumentor::PASSTHROUGH_ENTRY:
301 {
302 if ((*args).size() != 0) {
303 LOG(ERROR) << "Number of arguments does not match. expect: 0, actual: " << (*args).size() << ", method name: get, event type: " << event;
304 break;
305 }
306 break;
307 }
308 case details::HidlInstrumentor::CLIENT_API_EXIT:
309 case details::HidlInstrumentor::SERVER_API_EXIT:
310 case details::HidlInstrumentor::PASSTHROUGH_EXIT:
311 {
312 if ((*args).size() != 1) {
313 LOG(ERROR) << "Number of return values does not match. expect: 1, actual: " << (*args).size() << ", method name: get, event type: " << event;
314 break;
315 }
316 auto *result_0 __attribute__((__unused__)) = msg.add_return_type_hidl();
317 sp<::android::hidl::memory::token::V1_0::IMemoryToken> *result_val_0 __attribute__((__unused__)) = reinterpret_cast<sp<::android::hidl::memory::token::V1_0::IMemoryToken>*> ((*args)[0]);
318 if (result_val_0 != nullptr) {
319 result_0->set_type(TYPE_HIDL_INTERFACE);
320 result_0->set_predefined_type("::android::hidl::memory::token::V1_0::IMemoryToken");
321 } else {
322 LOG(WARNING) << "return value 0 is null.";
323 }
324 break;
325 }
326 default:
327 {
328 LOG(WARNING) << "not supported. ";
329 break;
330 }
331 }
332 }
333 }
334 profiler.AddTraceEvent(event, package, version, interface, msg);
335 }
336 }
337
338 } // namespace vts
339 } // namespace android
340