1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3
4
5 #include <string.h>
6 #include "magma_opcodes.h"
7
8 #include "magma_enc.h"
9
10
11 #include <vector>
12
13 #include <stdio.h>
14
15 // TODO(fxbug.dev/42073574): Why is modification needed for these two includes?
16 #include "aemu/base/Tracing.h"
17 #include "cutils/log.h"
18
19 #include "EncoderDebug.h"
20
21 using gfxstream::guest::ChecksumCalculator;
22
23 using gfxstream::guest::IOStream;
24
25 namespace {
26
enc_unsupported()27 void enc_unsupported()
28 {
29 ALOGE("Function is unsupported\n");
30 }
31
magma_device_import_enc(void * self,magma_handle_t device_channel,magma_device_t * device_out)32 magma_status_t magma_device_import_enc(void *self , magma_handle_t device_channel, magma_device_t* device_out)
33 {
34 ENCODER_DEBUG_LOG("magma_device_import(device_channel:%u, device_out:%p)", device_channel, device_out);
35 AEMU_SCOPED_TRACE("magma_device_import encode");
36
37 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
38 IOStream *stream = ctx->m_stream;
39 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
40 bool useChecksum = checksumCalculator->getVersion() > 0;
41
42 const unsigned int __size_device_out = sizeof(magma_device_t);
43 unsigned char *ptr;
44 unsigned char *buf;
45 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
46 const size_t checksumSize = checksumCalculator->checksumByteSize();
47 const size_t totalSize = sizeWithoutChecksum + checksumSize;
48 buf = stream->alloc(totalSize);
49 ptr = buf;
50 int tmp = OP_magma_device_import;memcpy(ptr, &tmp, 4); ptr += 4;
51 memcpy(ptr, &totalSize, 4); ptr += 4;
52
53 memcpy(ptr, &device_channel, 4); ptr += 4;
54 memcpy(ptr, &__size_device_out, 4); ptr += 4;
55
56 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
57 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
58
59 stream->readback(device_out, __size_device_out);
60 if (useChecksum) checksumCalculator->addBuffer(device_out, __size_device_out);
61
62 magma_status_t retval;
63 stream->readback(&retval, 4);
64 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
65 if (useChecksum) {
66 unsigned char *checksumBufPtr = NULL;
67 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
68 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
69 stream->readback(checksumBufPtr, checksumSize);
70 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
71 ALOGE("magma_device_import: GL communication error, please report this issue to b.android.com.\n");
72 abort();
73 }
74 }
75 return retval;
76 }
77
magma_device_release_enc(void * self,magma_device_t device)78 void magma_device_release_enc(void *self , magma_device_t device)
79 {
80 ENCODER_DEBUG_LOG("magma_device_release(device:%lu)", device);
81 AEMU_SCOPED_TRACE("magma_device_release encode");
82
83 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
84 IOStream *stream = ctx->m_stream;
85 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
86 bool useChecksum = checksumCalculator->getVersion() > 0;
87
88 unsigned char *ptr;
89 unsigned char *buf;
90 const size_t sizeWithoutChecksum = 8 + 8;
91 const size_t checksumSize = checksumCalculator->checksumByteSize();
92 const size_t totalSize = sizeWithoutChecksum + checksumSize;
93 buf = stream->alloc(totalSize);
94 ptr = buf;
95 int tmp = OP_magma_device_release;memcpy(ptr, &tmp, 4); ptr += 4;
96 memcpy(ptr, &totalSize, 4); ptr += 4;
97
98 memcpy(ptr, &device, 8); ptr += 8;
99
100 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
101 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
102
103 }
104
magma_device_query_enc(void * self,magma_device_t device,uint64_t id,magma_handle_t * result_buffer_out,uint64_t * result_out)105 magma_status_t magma_device_query_enc(void *self , magma_device_t device, uint64_t id, magma_handle_t* result_buffer_out, uint64_t* result_out)
106 {
107 ENCODER_DEBUG_LOG("magma_device_query(device:%lu, id:%lu, result_buffer_out:%p, result_out:%p)", device, id, result_buffer_out, result_out);
108 AEMU_SCOPED_TRACE("magma_device_query encode");
109
110 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
111 IOStream *stream = ctx->m_stream;
112 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
113 bool useChecksum = checksumCalculator->getVersion() > 0;
114
115 const unsigned int __size_result_buffer_out = sizeof(magma_handle_t);
116 const unsigned int __size_result_out = sizeof(uint64_t);
117 unsigned char *ptr;
118 unsigned char *buf;
119 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 2*4;
120 const size_t checksumSize = checksumCalculator->checksumByteSize();
121 const size_t totalSize = sizeWithoutChecksum + checksumSize;
122 buf = stream->alloc(totalSize);
123 ptr = buf;
124 int tmp = OP_magma_device_query;memcpy(ptr, &tmp, 4); ptr += 4;
125 memcpy(ptr, &totalSize, 4); ptr += 4;
126
127 memcpy(ptr, &device, 8); ptr += 8;
128 memcpy(ptr, &id, 8); ptr += 8;
129 memcpy(ptr, &__size_result_buffer_out, 4); ptr += 4;
130 memcpy(ptr, &__size_result_out, 4); ptr += 4;
131
132 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
133 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
134
135 stream->readback(result_buffer_out, __size_result_buffer_out);
136 if (useChecksum) checksumCalculator->addBuffer(result_buffer_out, __size_result_buffer_out);
137 stream->readback(result_out, __size_result_out);
138 if (useChecksum) checksumCalculator->addBuffer(result_out, __size_result_out);
139
140 magma_status_t retval;
141 stream->readback(&retval, 4);
142 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
143 if (useChecksum) {
144 unsigned char *checksumBufPtr = NULL;
145 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
146 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
147 stream->readback(checksumBufPtr, checksumSize);
148 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
149 ALOGE("magma_device_query: GL communication error, please report this issue to b.android.com.\n");
150 abort();
151 }
152 }
153 return retval;
154 }
155
magma_device_query_fudge_enc(void * self,magma_device_t device,uint64_t id,magma_bool_t host_allocate,uint64_t * result_buffer_mapping_id_inout,uint64_t * result_buffer_size_inout,uint64_t * result_out)156 magma_status_t magma_device_query_fudge_enc(void *self , magma_device_t device, uint64_t id, magma_bool_t host_allocate, uint64_t* result_buffer_mapping_id_inout, uint64_t* result_buffer_size_inout, uint64_t* result_out)
157 {
158 ENCODER_DEBUG_LOG("magma_device_query_fudge(device:%lu, id:%lu, host_allocate:%hhu, result_buffer_mapping_id_inout:%p, result_buffer_size_inout:%p, result_out:%p)", device, id, host_allocate, result_buffer_mapping_id_inout, result_buffer_size_inout, result_out);
159 AEMU_SCOPED_TRACE("magma_device_query_fudge encode");
160
161 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
162 IOStream *stream = ctx->m_stream;
163 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
164 bool useChecksum = checksumCalculator->getVersion() > 0;
165
166 const unsigned int __size_result_buffer_mapping_id_inout = sizeof(uint64_t);
167 const unsigned int __size_result_buffer_size_inout = sizeof(uint64_t);
168 const unsigned int __size_result_out = sizeof(uint64_t);
169 unsigned char *ptr;
170 unsigned char *buf;
171 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 1 + __size_result_buffer_mapping_id_inout + __size_result_buffer_size_inout + 0 + 3*4;
172 const size_t checksumSize = checksumCalculator->checksumByteSize();
173 const size_t totalSize = sizeWithoutChecksum + checksumSize;
174 buf = stream->alloc(totalSize);
175 ptr = buf;
176 int tmp = OP_magma_device_query_fudge;memcpy(ptr, &tmp, 4); ptr += 4;
177 memcpy(ptr, &totalSize, 4); ptr += 4;
178
179 memcpy(ptr, &device, 8); ptr += 8;
180 memcpy(ptr, &id, 8); ptr += 8;
181 memcpy(ptr, &host_allocate, 1); ptr += 1;
182 memcpy(ptr, &__size_result_buffer_mapping_id_inout, 4); ptr += 4;
183 memcpy(ptr, result_buffer_mapping_id_inout, __size_result_buffer_mapping_id_inout);ptr += __size_result_buffer_mapping_id_inout;
184 memcpy(ptr, &__size_result_buffer_size_inout, 4); ptr += 4;
185 memcpy(ptr, result_buffer_size_inout, __size_result_buffer_size_inout);ptr += __size_result_buffer_size_inout;
186 memcpy(ptr, &__size_result_out, 4); ptr += 4;
187
188 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
189 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
190
191 stream->readback(result_buffer_mapping_id_inout, __size_result_buffer_mapping_id_inout);
192 if (useChecksum) checksumCalculator->addBuffer(result_buffer_mapping_id_inout, __size_result_buffer_mapping_id_inout);
193 stream->readback(result_buffer_size_inout, __size_result_buffer_size_inout);
194 if (useChecksum) checksumCalculator->addBuffer(result_buffer_size_inout, __size_result_buffer_size_inout);
195 stream->readback(result_out, __size_result_out);
196 if (useChecksum) checksumCalculator->addBuffer(result_out, __size_result_out);
197
198 magma_status_t retval;
199 stream->readback(&retval, 4);
200 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
201 if (useChecksum) {
202 unsigned char *checksumBufPtr = NULL;
203 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
204 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
205 stream->readback(checksumBufPtr, checksumSize);
206 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
207 ALOGE("magma_device_query_fudge: GL communication error, please report this issue to b.android.com.\n");
208 abort();
209 }
210 }
211 return retval;
212 }
213
magma_device_create_connection_enc(void * self,magma_device_t device,magma_connection_t * connection_out)214 magma_status_t magma_device_create_connection_enc(void *self , magma_device_t device, magma_connection_t* connection_out)
215 {
216 ENCODER_DEBUG_LOG("magma_device_create_connection(device:%lu, connection_out:%p)", device, connection_out);
217 AEMU_SCOPED_TRACE("magma_device_create_connection encode");
218
219 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
220 IOStream *stream = ctx->m_stream;
221 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
222 bool useChecksum = checksumCalculator->getVersion() > 0;
223
224 const unsigned int __size_connection_out = sizeof(magma_connection_t);
225 unsigned char *ptr;
226 unsigned char *buf;
227 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
228 const size_t checksumSize = checksumCalculator->checksumByteSize();
229 const size_t totalSize = sizeWithoutChecksum + checksumSize;
230 buf = stream->alloc(totalSize);
231 ptr = buf;
232 int tmp = OP_magma_device_create_connection;memcpy(ptr, &tmp, 4); ptr += 4;
233 memcpy(ptr, &totalSize, 4); ptr += 4;
234
235 memcpy(ptr, &device, 8); ptr += 8;
236 memcpy(ptr, &__size_connection_out, 4); ptr += 4;
237
238 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
239 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
240
241 stream->readback(connection_out, __size_connection_out);
242 if (useChecksum) checksumCalculator->addBuffer(connection_out, __size_connection_out);
243
244 magma_status_t retval;
245 stream->readback(&retval, 4);
246 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
247 if (useChecksum) {
248 unsigned char *checksumBufPtr = NULL;
249 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
250 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
251 stream->readback(checksumBufPtr, checksumSize);
252 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
253 ALOGE("magma_device_create_connection: GL communication error, please report this issue to b.android.com.\n");
254 abort();
255 }
256 }
257 return retval;
258 }
259
magma_connection_release_enc(void * self,magma_connection_t connection)260 void magma_connection_release_enc(void *self , magma_connection_t connection)
261 {
262 ENCODER_DEBUG_LOG("magma_connection_release(connection:%lu)", connection);
263 AEMU_SCOPED_TRACE("magma_connection_release encode");
264
265 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
266 IOStream *stream = ctx->m_stream;
267 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
268 bool useChecksum = checksumCalculator->getVersion() > 0;
269
270 unsigned char *ptr;
271 unsigned char *buf;
272 const size_t sizeWithoutChecksum = 8 + 8;
273 const size_t checksumSize = checksumCalculator->checksumByteSize();
274 const size_t totalSize = sizeWithoutChecksum + checksumSize;
275 buf = stream->alloc(totalSize);
276 ptr = buf;
277 int tmp = OP_magma_connection_release;memcpy(ptr, &tmp, 4); ptr += 4;
278 memcpy(ptr, &totalSize, 4); ptr += 4;
279
280 memcpy(ptr, &connection, 8); ptr += 8;
281
282 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
283 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
284
285 }
286
magma_connection_get_error_enc(void * self,magma_connection_t connection)287 magma_status_t magma_connection_get_error_enc(void *self , magma_connection_t connection)
288 {
289 ENCODER_DEBUG_LOG("magma_connection_get_error(connection:%lu)", connection);
290 AEMU_SCOPED_TRACE("magma_connection_get_error encode");
291
292 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
293 IOStream *stream = ctx->m_stream;
294 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
295 bool useChecksum = checksumCalculator->getVersion() > 0;
296
297 unsigned char *ptr;
298 unsigned char *buf;
299 const size_t sizeWithoutChecksum = 8 + 8;
300 const size_t checksumSize = checksumCalculator->checksumByteSize();
301 const size_t totalSize = sizeWithoutChecksum + checksumSize;
302 buf = stream->alloc(totalSize);
303 ptr = buf;
304 int tmp = OP_magma_connection_get_error;memcpy(ptr, &tmp, 4); ptr += 4;
305 memcpy(ptr, &totalSize, 4); ptr += 4;
306
307 memcpy(ptr, &connection, 8); ptr += 8;
308
309 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
310 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
311
312
313 magma_status_t retval;
314 stream->readback(&retval, 4);
315 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
316 if (useChecksum) {
317 unsigned char *checksumBufPtr = NULL;
318 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
319 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
320 stream->readback(checksumBufPtr, checksumSize);
321 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
322 ALOGE("magma_connection_get_error: GL communication error, please report this issue to b.android.com.\n");
323 abort();
324 }
325 }
326 return retval;
327 }
328
magma_connection_create_context_enc(void * self,magma_connection_t connection,uint32_t * context_id_out)329 magma_status_t magma_connection_create_context_enc(void *self , magma_connection_t connection, uint32_t* context_id_out)
330 {
331 ENCODER_DEBUG_LOG("magma_connection_create_context(connection:%lu, context_id_out:%p)", connection, context_id_out);
332 AEMU_SCOPED_TRACE("magma_connection_create_context encode");
333
334 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
335 IOStream *stream = ctx->m_stream;
336 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
337 bool useChecksum = checksumCalculator->getVersion() > 0;
338
339 const unsigned int __size_context_id_out = sizeof(uint32_t);
340 unsigned char *ptr;
341 unsigned char *buf;
342 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
343 const size_t checksumSize = checksumCalculator->checksumByteSize();
344 const size_t totalSize = sizeWithoutChecksum + checksumSize;
345 buf = stream->alloc(totalSize);
346 ptr = buf;
347 int tmp = OP_magma_connection_create_context;memcpy(ptr, &tmp, 4); ptr += 4;
348 memcpy(ptr, &totalSize, 4); ptr += 4;
349
350 memcpy(ptr, &connection, 8); ptr += 8;
351 memcpy(ptr, &__size_context_id_out, 4); ptr += 4;
352
353 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
354 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
355
356 stream->readback(context_id_out, __size_context_id_out);
357 if (useChecksum) checksumCalculator->addBuffer(context_id_out, __size_context_id_out);
358
359 magma_status_t retval;
360 stream->readback(&retval, 4);
361 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
362 if (useChecksum) {
363 unsigned char *checksumBufPtr = NULL;
364 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
365 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
366 stream->readback(checksumBufPtr, checksumSize);
367 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
368 ALOGE("magma_connection_create_context: GL communication error, please report this issue to b.android.com.\n");
369 abort();
370 }
371 }
372 return retval;
373 }
374
magma_connection_release_context_enc(void * self,magma_connection_t connection,uint32_t context_id)375 void magma_connection_release_context_enc(void *self , magma_connection_t connection, uint32_t context_id)
376 {
377 ENCODER_DEBUG_LOG("magma_connection_release_context(connection:%lu, context_id:%u)", connection, context_id);
378 AEMU_SCOPED_TRACE("magma_connection_release_context encode");
379
380 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
381 IOStream *stream = ctx->m_stream;
382 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
383 bool useChecksum = checksumCalculator->getVersion() > 0;
384
385 unsigned char *ptr;
386 unsigned char *buf;
387 const size_t sizeWithoutChecksum = 8 + 8 + 4;
388 const size_t checksumSize = checksumCalculator->checksumByteSize();
389 const size_t totalSize = sizeWithoutChecksum + checksumSize;
390 buf = stream->alloc(totalSize);
391 ptr = buf;
392 int tmp = OP_magma_connection_release_context;memcpy(ptr, &tmp, 4); ptr += 4;
393 memcpy(ptr, &totalSize, 4); ptr += 4;
394
395 memcpy(ptr, &connection, 8); ptr += 8;
396 memcpy(ptr, &context_id, 4); ptr += 4;
397
398 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
399 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
400
401 }
402
magma_connection_create_buffer_enc(void * self,magma_connection_t connection,uint64_t size,uint64_t * size_out,magma_buffer_t * buffer_out,magma_buffer_id_t * id_out)403 magma_status_t magma_connection_create_buffer_enc(void *self , magma_connection_t connection, uint64_t size, uint64_t* size_out, magma_buffer_t* buffer_out, magma_buffer_id_t* id_out)
404 {
405 ENCODER_DEBUG_LOG("magma_connection_create_buffer(connection:%lu, size:%lu, size_out:%p, buffer_out:%p, id_out:%p)", connection, size, size_out, buffer_out, id_out);
406 AEMU_SCOPED_TRACE("magma_connection_create_buffer encode");
407
408 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
409 IOStream *stream = ctx->m_stream;
410 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
411 bool useChecksum = checksumCalculator->getVersion() > 0;
412
413 const unsigned int __size_size_out = sizeof(uint64_t);
414 const unsigned int __size_buffer_out = sizeof(magma_buffer_t);
415 const unsigned int __size_id_out = sizeof(magma_buffer_id_t);
416 unsigned char *ptr;
417 unsigned char *buf;
418 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 0 + 3*4;
419 const size_t checksumSize = checksumCalculator->checksumByteSize();
420 const size_t totalSize = sizeWithoutChecksum + checksumSize;
421 buf = stream->alloc(totalSize);
422 ptr = buf;
423 int tmp = OP_magma_connection_create_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
424 memcpy(ptr, &totalSize, 4); ptr += 4;
425
426 memcpy(ptr, &connection, 8); ptr += 8;
427 memcpy(ptr, &size, 8); ptr += 8;
428 memcpy(ptr, &__size_size_out, 4); ptr += 4;
429 memcpy(ptr, &__size_buffer_out, 4); ptr += 4;
430 memcpy(ptr, &__size_id_out, 4); ptr += 4;
431
432 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
433 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
434
435 stream->readback(size_out, __size_size_out);
436 if (useChecksum) checksumCalculator->addBuffer(size_out, __size_size_out);
437 stream->readback(buffer_out, __size_buffer_out);
438 if (useChecksum) checksumCalculator->addBuffer(buffer_out, __size_buffer_out);
439 stream->readback(id_out, __size_id_out);
440 if (useChecksum) checksumCalculator->addBuffer(id_out, __size_id_out);
441
442 magma_status_t retval;
443 stream->readback(&retval, 4);
444 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
445 if (useChecksum) {
446 unsigned char *checksumBufPtr = NULL;
447 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
448 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
449 stream->readback(checksumBufPtr, checksumSize);
450 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
451 ALOGE("magma_connection_create_buffer: GL communication error, please report this issue to b.android.com.\n");
452 abort();
453 }
454 }
455 return retval;
456 }
457
magma_connection_release_buffer_enc(void * self,magma_connection_t connection,magma_buffer_t buffer)458 void magma_connection_release_buffer_enc(void *self , magma_connection_t connection, magma_buffer_t buffer)
459 {
460 ENCODER_DEBUG_LOG("magma_connection_release_buffer(connection:%lu, buffer:%lu)", connection, buffer);
461 AEMU_SCOPED_TRACE("magma_connection_release_buffer encode");
462
463 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
464 IOStream *stream = ctx->m_stream;
465 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
466 bool useChecksum = checksumCalculator->getVersion() > 0;
467
468 unsigned char *ptr;
469 unsigned char *buf;
470 const size_t sizeWithoutChecksum = 8 + 8 + 8;
471 const size_t checksumSize = checksumCalculator->checksumByteSize();
472 const size_t totalSize = sizeWithoutChecksum + checksumSize;
473 buf = stream->alloc(totalSize);
474 ptr = buf;
475 int tmp = OP_magma_connection_release_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
476 memcpy(ptr, &totalSize, 4); ptr += 4;
477
478 memcpy(ptr, &connection, 8); ptr += 8;
479 memcpy(ptr, &buffer, 8); ptr += 8;
480
481 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
482 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
483
484 }
485
magma_connection_import_buffer_enc(void * self,magma_connection_t connection,magma_handle_t buffer_handle,uint64_t * size_out,magma_buffer_t * buffer_out,magma_buffer_id_t * id_out)486 magma_status_t magma_connection_import_buffer_enc(void *self , magma_connection_t connection, magma_handle_t buffer_handle, uint64_t* size_out, magma_buffer_t* buffer_out, magma_buffer_id_t* id_out)
487 {
488 ENCODER_DEBUG_LOG("magma_connection_import_buffer(connection:%lu, buffer_handle:%u, size_out:%p, buffer_out:%p, id_out:%p)", connection, buffer_handle, size_out, buffer_out, id_out);
489 AEMU_SCOPED_TRACE("magma_connection_import_buffer encode");
490
491 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
492 IOStream *stream = ctx->m_stream;
493 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
494 bool useChecksum = checksumCalculator->getVersion() > 0;
495
496 const unsigned int __size_size_out = sizeof(uint64_t);
497 const unsigned int __size_buffer_out = sizeof(magma_buffer_t);
498 const unsigned int __size_id_out = sizeof(magma_buffer_id_t);
499 unsigned char *ptr;
500 unsigned char *buf;
501 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 0 + 0 + 0 + 3*4;
502 const size_t checksumSize = checksumCalculator->checksumByteSize();
503 const size_t totalSize = sizeWithoutChecksum + checksumSize;
504 buf = stream->alloc(totalSize);
505 ptr = buf;
506 int tmp = OP_magma_connection_import_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
507 memcpy(ptr, &totalSize, 4); ptr += 4;
508
509 memcpy(ptr, &connection, 8); ptr += 8;
510 memcpy(ptr, &buffer_handle, 4); ptr += 4;
511 memcpy(ptr, &__size_size_out, 4); ptr += 4;
512 memcpy(ptr, &__size_buffer_out, 4); ptr += 4;
513 memcpy(ptr, &__size_id_out, 4); ptr += 4;
514
515 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
516 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
517
518 stream->readback(size_out, __size_size_out);
519 if (useChecksum) checksumCalculator->addBuffer(size_out, __size_size_out);
520 stream->readback(buffer_out, __size_buffer_out);
521 if (useChecksum) checksumCalculator->addBuffer(buffer_out, __size_buffer_out);
522 stream->readback(id_out, __size_id_out);
523 if (useChecksum) checksumCalculator->addBuffer(id_out, __size_id_out);
524
525 magma_status_t retval;
526 stream->readback(&retval, 4);
527 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
528 if (useChecksum) {
529 unsigned char *checksumBufPtr = NULL;
530 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
531 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
532 stream->readback(checksumBufPtr, checksumSize);
533 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
534 ALOGE("magma_connection_import_buffer: GL communication error, please report this issue to b.android.com.\n");
535 abort();
536 }
537 }
538 return retval;
539 }
540
magma_connection_create_semaphore_enc(void * self,magma_connection_t connection,magma_semaphore_t * semaphore_out,magma_semaphore_id_t * id_out)541 magma_status_t magma_connection_create_semaphore_enc(void *self , magma_connection_t connection, magma_semaphore_t* semaphore_out, magma_semaphore_id_t* id_out)
542 {
543 ENCODER_DEBUG_LOG("magma_connection_create_semaphore(connection:%lu, semaphore_out:%p, id_out:%p)", connection, semaphore_out, id_out);
544 AEMU_SCOPED_TRACE("magma_connection_create_semaphore encode");
545
546 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
547 IOStream *stream = ctx->m_stream;
548 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
549 bool useChecksum = checksumCalculator->getVersion() > 0;
550
551 const unsigned int __size_semaphore_out = sizeof(magma_semaphore_t);
552 const unsigned int __size_id_out = sizeof(magma_semaphore_id_t);
553 unsigned char *ptr;
554 unsigned char *buf;
555 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 0 + 2*4;
556 const size_t checksumSize = checksumCalculator->checksumByteSize();
557 const size_t totalSize = sizeWithoutChecksum + checksumSize;
558 buf = stream->alloc(totalSize);
559 ptr = buf;
560 int tmp = OP_magma_connection_create_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
561 memcpy(ptr, &totalSize, 4); ptr += 4;
562
563 memcpy(ptr, &connection, 8); ptr += 8;
564 memcpy(ptr, &__size_semaphore_out, 4); ptr += 4;
565 memcpy(ptr, &__size_id_out, 4); ptr += 4;
566
567 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
568 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
569
570 stream->readback(semaphore_out, __size_semaphore_out);
571 if (useChecksum) checksumCalculator->addBuffer(semaphore_out, __size_semaphore_out);
572 stream->readback(id_out, __size_id_out);
573 if (useChecksum) checksumCalculator->addBuffer(id_out, __size_id_out);
574
575 magma_status_t retval;
576 stream->readback(&retval, 4);
577 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
578 if (useChecksum) {
579 unsigned char *checksumBufPtr = NULL;
580 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
581 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
582 stream->readback(checksumBufPtr, checksumSize);
583 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
584 ALOGE("magma_connection_create_semaphore: GL communication error, please report this issue to b.android.com.\n");
585 abort();
586 }
587 }
588 return retval;
589 }
590
magma_connection_release_semaphore_enc(void * self,magma_connection_t connection,magma_semaphore_t semaphore)591 void magma_connection_release_semaphore_enc(void *self , magma_connection_t connection, magma_semaphore_t semaphore)
592 {
593 ENCODER_DEBUG_LOG("magma_connection_release_semaphore(connection:%lu, semaphore:%lu)", connection, semaphore);
594 AEMU_SCOPED_TRACE("magma_connection_release_semaphore encode");
595
596 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
597 IOStream *stream = ctx->m_stream;
598 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
599 bool useChecksum = checksumCalculator->getVersion() > 0;
600
601 unsigned char *ptr;
602 unsigned char *buf;
603 const size_t sizeWithoutChecksum = 8 + 8 + 8;
604 const size_t checksumSize = checksumCalculator->checksumByteSize();
605 const size_t totalSize = sizeWithoutChecksum + checksumSize;
606 buf = stream->alloc(totalSize);
607 ptr = buf;
608 int tmp = OP_magma_connection_release_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
609 memcpy(ptr, &totalSize, 4); ptr += 4;
610
611 memcpy(ptr, &connection, 8); ptr += 8;
612 memcpy(ptr, &semaphore, 8); ptr += 8;
613
614 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
615 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
616
617 }
618
magma_connection_import_semaphore_enc(void * self,magma_connection_t connection,magma_handle_t semaphore_handle,magma_semaphore_t * semaphore_out,magma_semaphore_id_t * id_out)619 magma_status_t magma_connection_import_semaphore_enc(void *self , magma_connection_t connection, magma_handle_t semaphore_handle, magma_semaphore_t* semaphore_out, magma_semaphore_id_t* id_out)
620 {
621 ENCODER_DEBUG_LOG("magma_connection_import_semaphore(connection:%lu, semaphore_handle:%u, semaphore_out:%p, id_out:%p)", connection, semaphore_handle, semaphore_out, id_out);
622 AEMU_SCOPED_TRACE("magma_connection_import_semaphore encode");
623
624 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
625 IOStream *stream = ctx->m_stream;
626 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
627 bool useChecksum = checksumCalculator->getVersion() > 0;
628
629 const unsigned int __size_semaphore_out = sizeof(magma_semaphore_t);
630 const unsigned int __size_id_out = sizeof(magma_semaphore_id_t);
631 unsigned char *ptr;
632 unsigned char *buf;
633 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 0 + 0 + 2*4;
634 const size_t checksumSize = checksumCalculator->checksumByteSize();
635 const size_t totalSize = sizeWithoutChecksum + checksumSize;
636 buf = stream->alloc(totalSize);
637 ptr = buf;
638 int tmp = OP_magma_connection_import_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
639 memcpy(ptr, &totalSize, 4); ptr += 4;
640
641 memcpy(ptr, &connection, 8); ptr += 8;
642 memcpy(ptr, &semaphore_handle, 4); ptr += 4;
643 memcpy(ptr, &__size_semaphore_out, 4); ptr += 4;
644 memcpy(ptr, &__size_id_out, 4); ptr += 4;
645
646 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
647 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
648
649 stream->readback(semaphore_out, __size_semaphore_out);
650 if (useChecksum) checksumCalculator->addBuffer(semaphore_out, __size_semaphore_out);
651 stream->readback(id_out, __size_id_out);
652 if (useChecksum) checksumCalculator->addBuffer(id_out, __size_id_out);
653
654 magma_status_t retval;
655 stream->readback(&retval, 4);
656 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
657 if (useChecksum) {
658 unsigned char *checksumBufPtr = NULL;
659 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
660 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
661 stream->readback(checksumBufPtr, checksumSize);
662 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
663 ALOGE("magma_connection_import_semaphore: GL communication error, please report this issue to b.android.com.\n");
664 abort();
665 }
666 }
667 return retval;
668 }
669
magma_connection_perform_buffer_op_enc(void * self,magma_connection_t connection,magma_buffer_t buffer,uint32_t options,uint64_t start_offset,uint64_t length)670 magma_status_t magma_connection_perform_buffer_op_enc(void *self , magma_connection_t connection, magma_buffer_t buffer, uint32_t options, uint64_t start_offset, uint64_t length)
671 {
672 ENCODER_DEBUG_LOG("magma_connection_perform_buffer_op(connection:%lu, buffer:%lu, options:%u, start_offset:%lu, length:%lu)", connection, buffer, options, start_offset, length);
673 AEMU_SCOPED_TRACE("magma_connection_perform_buffer_op encode");
674
675 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
676 IOStream *stream = ctx->m_stream;
677 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
678 bool useChecksum = checksumCalculator->getVersion() > 0;
679
680 unsigned char *ptr;
681 unsigned char *buf;
682 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 4 + 8 + 8;
683 const size_t checksumSize = checksumCalculator->checksumByteSize();
684 const size_t totalSize = sizeWithoutChecksum + checksumSize;
685 buf = stream->alloc(totalSize);
686 ptr = buf;
687 int tmp = OP_magma_connection_perform_buffer_op;memcpy(ptr, &tmp, 4); ptr += 4;
688 memcpy(ptr, &totalSize, 4); ptr += 4;
689
690 memcpy(ptr, &connection, 8); ptr += 8;
691 memcpy(ptr, &buffer, 8); ptr += 8;
692 memcpy(ptr, &options, 4); ptr += 4;
693 memcpy(ptr, &start_offset, 8); ptr += 8;
694 memcpy(ptr, &length, 8); ptr += 8;
695
696 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
697 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
698
699
700 magma_status_t retval;
701 stream->readback(&retval, 4);
702 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
703 if (useChecksum) {
704 unsigned char *checksumBufPtr = NULL;
705 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
706 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
707 stream->readback(checksumBufPtr, checksumSize);
708 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
709 ALOGE("magma_connection_perform_buffer_op: GL communication error, please report this issue to b.android.com.\n");
710 abort();
711 }
712 }
713 return retval;
714 }
715
magma_connection_map_buffer_enc(void * self,magma_connection_t connection,uint64_t hw_va,magma_buffer_t buffer,uint64_t offset,uint64_t length,uint64_t map_flags)716 magma_status_t magma_connection_map_buffer_enc(void *self , magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer, uint64_t offset, uint64_t length, uint64_t map_flags)
717 {
718 ENCODER_DEBUG_LOG("magma_connection_map_buffer(connection:%lu, hw_va:%lu, buffer:%lu, offset:%lu, length:%lu, map_flags:%lu)", connection, hw_va, buffer, offset, length, map_flags);
719 AEMU_SCOPED_TRACE("magma_connection_map_buffer encode");
720
721 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
722 IOStream *stream = ctx->m_stream;
723 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
724 bool useChecksum = checksumCalculator->getVersion() > 0;
725
726 unsigned char *ptr;
727 unsigned char *buf;
728 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8 + 8 + 8 + 8;
729 const size_t checksumSize = checksumCalculator->checksumByteSize();
730 const size_t totalSize = sizeWithoutChecksum + checksumSize;
731 buf = stream->alloc(totalSize);
732 ptr = buf;
733 int tmp = OP_magma_connection_map_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
734 memcpy(ptr, &totalSize, 4); ptr += 4;
735
736 memcpy(ptr, &connection, 8); ptr += 8;
737 memcpy(ptr, &hw_va, 8); ptr += 8;
738 memcpy(ptr, &buffer, 8); ptr += 8;
739 memcpy(ptr, &offset, 8); ptr += 8;
740 memcpy(ptr, &length, 8); ptr += 8;
741 memcpy(ptr, &map_flags, 8); ptr += 8;
742
743 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
744 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
745
746
747 magma_status_t retval;
748 stream->readback(&retval, 4);
749 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
750 if (useChecksum) {
751 unsigned char *checksumBufPtr = NULL;
752 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
753 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
754 stream->readback(checksumBufPtr, checksumSize);
755 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
756 ALOGE("magma_connection_map_buffer: GL communication error, please report this issue to b.android.com.\n");
757 abort();
758 }
759 }
760 return retval;
761 }
762
magma_connection_unmap_buffer_enc(void * self,magma_connection_t connection,uint64_t hw_va,magma_buffer_t buffer)763 void magma_connection_unmap_buffer_enc(void *self , magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer)
764 {
765 ENCODER_DEBUG_LOG("magma_connection_unmap_buffer(connection:%lu, hw_va:%lu, buffer:%lu)", connection, hw_va, buffer);
766 AEMU_SCOPED_TRACE("magma_connection_unmap_buffer encode");
767
768 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
769 IOStream *stream = ctx->m_stream;
770 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
771 bool useChecksum = checksumCalculator->getVersion() > 0;
772
773 unsigned char *ptr;
774 unsigned char *buf;
775 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8;
776 const size_t checksumSize = checksumCalculator->checksumByteSize();
777 const size_t totalSize = sizeWithoutChecksum + checksumSize;
778 buf = stream->alloc(totalSize);
779 ptr = buf;
780 int tmp = OP_magma_connection_unmap_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
781 memcpy(ptr, &totalSize, 4); ptr += 4;
782
783 memcpy(ptr, &connection, 8); ptr += 8;
784 memcpy(ptr, &hw_va, 8); ptr += 8;
785 memcpy(ptr, &buffer, 8); ptr += 8;
786
787 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
788 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
789
790 }
791
magma_connection_execute_command_enc(void * self,magma_connection_t connection,uint32_t context_id,magma_command_descriptor_t * descriptor)792 magma_status_t magma_connection_execute_command_enc(void *self , magma_connection_t connection, uint32_t context_id, magma_command_descriptor_t* descriptor)
793 {
794 ENCODER_DEBUG_LOG("magma_connection_execute_command(connection:%lu, context_id:%u, descriptor:%p)", connection, context_id, descriptor);
795 AEMU_SCOPED_TRACE("magma_connection_execute_command encode");
796
797 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
798 IOStream *stream = ctx->m_stream;
799 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
800 bool useChecksum = checksumCalculator->getVersion() > 0;
801
802 const unsigned int __size_descriptor = sizeof(magma_command_descriptor_t);
803 unsigned char *ptr;
804 unsigned char *buf;
805 const size_t sizeWithoutChecksum = 8 + 8 + 4 + __size_descriptor + 1*4;
806 const size_t checksumSize = checksumCalculator->checksumByteSize();
807 const size_t totalSize = sizeWithoutChecksum + checksumSize;
808 buf = stream->alloc(totalSize);
809 ptr = buf;
810 int tmp = OP_magma_connection_execute_command;memcpy(ptr, &tmp, 4); ptr += 4;
811 memcpy(ptr, &totalSize, 4); ptr += 4;
812
813 memcpy(ptr, &connection, 8); ptr += 8;
814 memcpy(ptr, &context_id, 4); ptr += 4;
815 memcpy(ptr, &__size_descriptor, 4); ptr += 4;
816 memcpy(ptr, descriptor, __size_descriptor);ptr += __size_descriptor;
817
818 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
819 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
820
821
822 magma_status_t retval;
823 stream->readback(&retval, 4);
824 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
825 if (useChecksum) {
826 unsigned char *checksumBufPtr = NULL;
827 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
828 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
829 stream->readback(checksumBufPtr, checksumSize);
830 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
831 ALOGE("magma_connection_execute_command: GL communication error, please report this issue to b.android.com.\n");
832 abort();
833 }
834 }
835 return retval;
836 }
837
magma_connection_execute_command_fudge_enc(void * self,magma_connection_t connection,uint32_t context_id,void * descriptor,uint64_t descriptor_size)838 magma_status_t magma_connection_execute_command_fudge_enc(void *self , magma_connection_t connection, uint32_t context_id, void* descriptor, uint64_t descriptor_size)
839 {
840 ENCODER_DEBUG_LOG("magma_connection_execute_command_fudge(connection:%lu, context_id:%u, descriptor:%p, descriptor_size:%lu)", connection, context_id, descriptor, descriptor_size);
841 AEMU_SCOPED_TRACE("magma_connection_execute_command_fudge encode");
842
843 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
844 IOStream *stream = ctx->m_stream;
845 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
846 bool useChecksum = checksumCalculator->getVersion() > 0;
847
848 const unsigned int __size_descriptor = descriptor_size;
849 unsigned char *ptr;
850 unsigned char *buf;
851 const size_t sizeWithoutChecksum = 8 + 8 + 4 + __size_descriptor + 8 + 1*4;
852 const size_t checksumSize = checksumCalculator->checksumByteSize();
853 const size_t totalSize = sizeWithoutChecksum + checksumSize;
854 buf = stream->alloc(totalSize);
855 ptr = buf;
856 int tmp = OP_magma_connection_execute_command_fudge;memcpy(ptr, &tmp, 4); ptr += 4;
857 memcpy(ptr, &totalSize, 4); ptr += 4;
858
859 memcpy(ptr, &connection, 8); ptr += 8;
860 memcpy(ptr, &context_id, 4); ptr += 4;
861 memcpy(ptr, &__size_descriptor, 4); ptr += 4;
862 memcpy(ptr, descriptor, __size_descriptor);ptr += __size_descriptor;
863 memcpy(ptr, &descriptor_size, 8); ptr += 8;
864
865 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
866 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
867
868
869 magma_status_t retval;
870 stream->readback(&retval, 4);
871 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
872 if (useChecksum) {
873 unsigned char *checksumBufPtr = NULL;
874 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
875 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
876 stream->readback(checksumBufPtr, checksumSize);
877 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
878 ALOGE("magma_connection_execute_command_fudge: GL communication error, please report this issue to b.android.com.\n");
879 abort();
880 }
881 }
882 return retval;
883 }
884
magma_connection_execute_immediate_commands_enc(void * self,magma_connection_t connection,uint32_t context_id,uint64_t command_count,magma_inline_command_buffer_t * command_buffers)885 magma_status_t magma_connection_execute_immediate_commands_enc(void *self , magma_connection_t connection, uint32_t context_id, uint64_t command_count, magma_inline_command_buffer_t* command_buffers)
886 {
887 ENCODER_DEBUG_LOG("magma_connection_execute_immediate_commands(connection:%lu, context_id:%u, command_count:%lu, command_buffers:%p)", connection, context_id, command_count, command_buffers);
888 AEMU_SCOPED_TRACE("magma_connection_execute_immediate_commands encode");
889
890 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
891 IOStream *stream = ctx->m_stream;
892 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
893 bool useChecksum = checksumCalculator->getVersion() > 0;
894
895 const unsigned int __size_command_buffers = command_count * sizeof(magma_inline_command_buffer_t);
896 unsigned char *ptr;
897 unsigned char *buf;
898 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8 + __size_command_buffers + 1*4;
899 const size_t checksumSize = checksumCalculator->checksumByteSize();
900 const size_t totalSize = sizeWithoutChecksum + checksumSize;
901 buf = stream->alloc(totalSize);
902 ptr = buf;
903 int tmp = OP_magma_connection_execute_immediate_commands;memcpy(ptr, &tmp, 4); ptr += 4;
904 memcpy(ptr, &totalSize, 4); ptr += 4;
905
906 memcpy(ptr, &connection, 8); ptr += 8;
907 memcpy(ptr, &context_id, 4); ptr += 4;
908 memcpy(ptr, &command_count, 8); ptr += 8;
909 memcpy(ptr, &__size_command_buffers, 4); ptr += 4;
910 memcpy(ptr, command_buffers, __size_command_buffers);ptr += __size_command_buffers;
911
912 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
913 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
914
915
916 magma_status_t retval;
917 stream->readback(&retval, 4);
918 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
919 if (useChecksum) {
920 unsigned char *checksumBufPtr = NULL;
921 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
922 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
923 stream->readback(checksumBufPtr, checksumSize);
924 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
925 ALOGE("magma_connection_execute_immediate_commands: GL communication error, please report this issue to b.android.com.\n");
926 abort();
927 }
928 }
929 return retval;
930 }
931
magma_connection_execute_immediate_commands_fudge_enc(void * self,magma_connection_t connection,uint32_t context_id,uint64_t command_count,void * command_buffers,uint64_t command_buffers_size,uint64_t * command_buffer_offsets)932 magma_status_t magma_connection_execute_immediate_commands_fudge_enc(void *self , magma_connection_t connection, uint32_t context_id, uint64_t command_count, void* command_buffers, uint64_t command_buffers_size, uint64_t* command_buffer_offsets)
933 {
934 ENCODER_DEBUG_LOG("magma_connection_execute_immediate_commands_fudge(connection:%lu, context_id:%u, command_count:%lu, command_buffers:%p, command_buffers_size:%lu, command_buffer_offsets:%p)", connection, context_id, command_count, command_buffers, command_buffers_size, command_buffer_offsets);
935 AEMU_SCOPED_TRACE("magma_connection_execute_immediate_commands_fudge encode");
936
937 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
938 IOStream *stream = ctx->m_stream;
939 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
940 bool useChecksum = checksumCalculator->getVersion() > 0;
941
942 const unsigned int __size_command_buffers = command_buffers_size;
943 const unsigned int __size_command_buffer_offsets = command_count * sizeof(uint64_t);
944 unsigned char *ptr;
945 unsigned char *buf;
946 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8 + __size_command_buffers + 8 + __size_command_buffer_offsets + 2*4;
947 const size_t checksumSize = checksumCalculator->checksumByteSize();
948 const size_t totalSize = sizeWithoutChecksum + checksumSize;
949 buf = stream->alloc(totalSize);
950 ptr = buf;
951 int tmp = OP_magma_connection_execute_immediate_commands_fudge;memcpy(ptr, &tmp, 4); ptr += 4;
952 memcpy(ptr, &totalSize, 4); ptr += 4;
953
954 memcpy(ptr, &connection, 8); ptr += 8;
955 memcpy(ptr, &context_id, 4); ptr += 4;
956 memcpy(ptr, &command_count, 8); ptr += 8;
957 memcpy(ptr, &__size_command_buffers, 4); ptr += 4;
958 memcpy(ptr, command_buffers, __size_command_buffers);ptr += __size_command_buffers;
959 memcpy(ptr, &command_buffers_size, 8); ptr += 8;
960 memcpy(ptr, &__size_command_buffer_offsets, 4); ptr += 4;
961 memcpy(ptr, command_buffer_offsets, __size_command_buffer_offsets);ptr += __size_command_buffer_offsets;
962
963 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
964 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
965
966
967 magma_status_t retval;
968 stream->readback(&retval, 4);
969 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
970 if (useChecksum) {
971 unsigned char *checksumBufPtr = NULL;
972 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
973 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
974 stream->readback(checksumBufPtr, checksumSize);
975 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
976 ALOGE("magma_connection_execute_immediate_commands_fudge: GL communication error, please report this issue to b.android.com.\n");
977 abort();
978 }
979 }
980 return retval;
981 }
982
magma_connection_flush_enc(void * self,magma_connection_t connection)983 magma_status_t magma_connection_flush_enc(void *self , magma_connection_t connection)
984 {
985 ENCODER_DEBUG_LOG("magma_connection_flush(connection:%lu)", connection);
986 AEMU_SCOPED_TRACE("magma_connection_flush encode");
987
988 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
989 IOStream *stream = ctx->m_stream;
990 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
991 bool useChecksum = checksumCalculator->getVersion() > 0;
992
993 unsigned char *ptr;
994 unsigned char *buf;
995 const size_t sizeWithoutChecksum = 8 + 8;
996 const size_t checksumSize = checksumCalculator->checksumByteSize();
997 const size_t totalSize = sizeWithoutChecksum + checksumSize;
998 buf = stream->alloc(totalSize);
999 ptr = buf;
1000 int tmp = OP_magma_connection_flush;memcpy(ptr, &tmp, 4); ptr += 4;
1001 memcpy(ptr, &totalSize, 4); ptr += 4;
1002
1003 memcpy(ptr, &connection, 8); ptr += 8;
1004
1005 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1006 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1007
1008
1009 magma_status_t retval;
1010 stream->readback(&retval, 4);
1011 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1012 if (useChecksum) {
1013 unsigned char *checksumBufPtr = NULL;
1014 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1015 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1016 stream->readback(checksumBufPtr, checksumSize);
1017 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1018 ALOGE("magma_connection_flush: GL communication error, please report this issue to b.android.com.\n");
1019 abort();
1020 }
1021 }
1022 return retval;
1023 }
1024
magma_connection_get_notification_channel_handle_enc(void * self,magma_connection_t connection)1025 magma_handle_t magma_connection_get_notification_channel_handle_enc(void *self , magma_connection_t connection)
1026 {
1027 ENCODER_DEBUG_LOG("magma_connection_get_notification_channel_handle(connection:%lu)", connection);
1028 AEMU_SCOPED_TRACE("magma_connection_get_notification_channel_handle encode");
1029
1030 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1031 IOStream *stream = ctx->m_stream;
1032 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1033 bool useChecksum = checksumCalculator->getVersion() > 0;
1034
1035 unsigned char *ptr;
1036 unsigned char *buf;
1037 const size_t sizeWithoutChecksum = 8 + 8;
1038 const size_t checksumSize = checksumCalculator->checksumByteSize();
1039 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1040 buf = stream->alloc(totalSize);
1041 ptr = buf;
1042 int tmp = OP_magma_connection_get_notification_channel_handle;memcpy(ptr, &tmp, 4); ptr += 4;
1043 memcpy(ptr, &totalSize, 4); ptr += 4;
1044
1045 memcpy(ptr, &connection, 8); ptr += 8;
1046
1047 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1048 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1049
1050
1051 magma_handle_t retval;
1052 stream->readback(&retval, 4);
1053 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1054 if (useChecksum) {
1055 unsigned char *checksumBufPtr = NULL;
1056 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1057 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1058 stream->readback(checksumBufPtr, checksumSize);
1059 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1060 ALOGE("magma_connection_get_notification_channel_handle: GL communication error, please report this issue to b.android.com.\n");
1061 abort();
1062 }
1063 }
1064 return retval;
1065 }
1066
magma_connection_read_notification_channel_enc(void * self,magma_connection_t connection,void * buffer,uint64_t buffer_size,uint64_t * buffer_size_out,magma_bool_t * more_data_out)1067 magma_status_t magma_connection_read_notification_channel_enc(void *self , magma_connection_t connection, void* buffer, uint64_t buffer_size, uint64_t* buffer_size_out, magma_bool_t* more_data_out)
1068 {
1069 ENCODER_DEBUG_LOG("magma_connection_read_notification_channel(connection:%lu, buffer:%p, buffer_size:%lu, buffer_size_out:%p, more_data_out:%p)", connection, buffer, buffer_size, buffer_size_out, more_data_out);
1070 AEMU_SCOPED_TRACE("magma_connection_read_notification_channel encode");
1071
1072 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1073 IOStream *stream = ctx->m_stream;
1074 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1075 bool useChecksum = checksumCalculator->getVersion() > 0;
1076
1077 const unsigned int __size_buffer = buffer_size;
1078 const unsigned int __size_buffer_size_out = sizeof(uint64_t);
1079 const unsigned int __size_more_data_out = sizeof(magma_bool_t);
1080 unsigned char *ptr;
1081 unsigned char *buf;
1082 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 8 + 0 + 0 + 3*4;
1083 const size_t checksumSize = checksumCalculator->checksumByteSize();
1084 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1085 buf = stream->alloc(totalSize);
1086 ptr = buf;
1087 int tmp = OP_magma_connection_read_notification_channel;memcpy(ptr, &tmp, 4); ptr += 4;
1088 memcpy(ptr, &totalSize, 4); ptr += 4;
1089
1090 memcpy(ptr, &connection, 8); ptr += 8;
1091 memcpy(ptr, &__size_buffer, 4); ptr += 4;
1092 memcpy(ptr, &buffer_size, 8); ptr += 8;
1093 memcpy(ptr, &__size_buffer_size_out, 4); ptr += 4;
1094 memcpy(ptr, &__size_more_data_out, 4); ptr += 4;
1095
1096 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1097 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1098
1099 stream->readback(buffer, __size_buffer);
1100 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
1101 stream->readback(buffer_size_out, __size_buffer_size_out);
1102 if (useChecksum) checksumCalculator->addBuffer(buffer_size_out, __size_buffer_size_out);
1103 stream->readback(more_data_out, __size_more_data_out);
1104 if (useChecksum) checksumCalculator->addBuffer(more_data_out, __size_more_data_out);
1105
1106 magma_status_t retval;
1107 stream->readback(&retval, 4);
1108 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1109 if (useChecksum) {
1110 unsigned char *checksumBufPtr = NULL;
1111 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1112 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1113 stream->readback(checksumBufPtr, checksumSize);
1114 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1115 ALOGE("magma_connection_read_notification_channel: GL communication error, please report this issue to b.android.com.\n");
1116 abort();
1117 }
1118 }
1119 return retval;
1120 }
1121
magma_buffer_clean_cache_enc(void * self,magma_buffer_t buffer,uint64_t offset,uint64_t size,magma_cache_operation_t operation)1122 magma_status_t magma_buffer_clean_cache_enc(void *self , magma_buffer_t buffer, uint64_t offset, uint64_t size, magma_cache_operation_t operation)
1123 {
1124 ENCODER_DEBUG_LOG("magma_buffer_clean_cache(buffer:%lu, offset:%lu, size:%lu, operation:%u)", buffer, offset, size, operation);
1125 AEMU_SCOPED_TRACE("magma_buffer_clean_cache encode");
1126
1127 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1128 IOStream *stream = ctx->m_stream;
1129 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1130 bool useChecksum = checksumCalculator->getVersion() > 0;
1131
1132 unsigned char *ptr;
1133 unsigned char *buf;
1134 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8 + 4;
1135 const size_t checksumSize = checksumCalculator->checksumByteSize();
1136 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1137 buf = stream->alloc(totalSize);
1138 ptr = buf;
1139 int tmp = OP_magma_buffer_clean_cache;memcpy(ptr, &tmp, 4); ptr += 4;
1140 memcpy(ptr, &totalSize, 4); ptr += 4;
1141
1142 memcpy(ptr, &buffer, 8); ptr += 8;
1143 memcpy(ptr, &offset, 8); ptr += 8;
1144 memcpy(ptr, &size, 8); ptr += 8;
1145 memcpy(ptr, &operation, 4); ptr += 4;
1146
1147 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1148 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1149
1150
1151 magma_status_t retval;
1152 stream->readback(&retval, 4);
1153 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1154 if (useChecksum) {
1155 unsigned char *checksumBufPtr = NULL;
1156 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1157 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1158 stream->readback(checksumBufPtr, checksumSize);
1159 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1160 ALOGE("magma_buffer_clean_cache: GL communication error, please report this issue to b.android.com.\n");
1161 abort();
1162 }
1163 }
1164 return retval;
1165 }
1166
magma_buffer_set_cache_policy_enc(void * self,magma_buffer_t buffer,magma_cache_policy_t policy)1167 magma_status_t magma_buffer_set_cache_policy_enc(void *self , magma_buffer_t buffer, magma_cache_policy_t policy)
1168 {
1169 ENCODER_DEBUG_LOG("magma_buffer_set_cache_policy(buffer:%lu, policy:%u)", buffer, policy);
1170 AEMU_SCOPED_TRACE("magma_buffer_set_cache_policy encode");
1171
1172 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1173 IOStream *stream = ctx->m_stream;
1174 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1175 bool useChecksum = checksumCalculator->getVersion() > 0;
1176
1177 unsigned char *ptr;
1178 unsigned char *buf;
1179 const size_t sizeWithoutChecksum = 8 + 8 + 4;
1180 const size_t checksumSize = checksumCalculator->checksumByteSize();
1181 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1182 buf = stream->alloc(totalSize);
1183 ptr = buf;
1184 int tmp = OP_magma_buffer_set_cache_policy;memcpy(ptr, &tmp, 4); ptr += 4;
1185 memcpy(ptr, &totalSize, 4); ptr += 4;
1186
1187 memcpy(ptr, &buffer, 8); ptr += 8;
1188 memcpy(ptr, &policy, 4); ptr += 4;
1189
1190 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1191 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1192
1193
1194 magma_status_t retval;
1195 stream->readback(&retval, 4);
1196 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1197 if (useChecksum) {
1198 unsigned char *checksumBufPtr = NULL;
1199 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1200 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1201 stream->readback(checksumBufPtr, checksumSize);
1202 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1203 ALOGE("magma_buffer_set_cache_policy: GL communication error, please report this issue to b.android.com.\n");
1204 abort();
1205 }
1206 }
1207 return retval;
1208 }
1209
magma_buffer_get_cache_policy_enc(void * self,magma_buffer_t buffer,magma_cache_policy_t * cache_policy_out)1210 magma_status_t magma_buffer_get_cache_policy_enc(void *self , magma_buffer_t buffer, magma_cache_policy_t* cache_policy_out)
1211 {
1212 ENCODER_DEBUG_LOG("magma_buffer_get_cache_policy(buffer:%lu, cache_policy_out:%p)", buffer, cache_policy_out);
1213 AEMU_SCOPED_TRACE("magma_buffer_get_cache_policy encode");
1214
1215 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1216 IOStream *stream = ctx->m_stream;
1217 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1218 bool useChecksum = checksumCalculator->getVersion() > 0;
1219
1220 const unsigned int __size_cache_policy_out = sizeof(magma_cache_policy_t);
1221 unsigned char *ptr;
1222 unsigned char *buf;
1223 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
1224 const size_t checksumSize = checksumCalculator->checksumByteSize();
1225 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1226 buf = stream->alloc(totalSize);
1227 ptr = buf;
1228 int tmp = OP_magma_buffer_get_cache_policy;memcpy(ptr, &tmp, 4); ptr += 4;
1229 memcpy(ptr, &totalSize, 4); ptr += 4;
1230
1231 memcpy(ptr, &buffer, 8); ptr += 8;
1232 memcpy(ptr, &__size_cache_policy_out, 4); ptr += 4;
1233
1234 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1235 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1236
1237 stream->readback(cache_policy_out, __size_cache_policy_out);
1238 if (useChecksum) checksumCalculator->addBuffer(cache_policy_out, __size_cache_policy_out);
1239
1240 magma_status_t retval;
1241 stream->readback(&retval, 4);
1242 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1243 if (useChecksum) {
1244 unsigned char *checksumBufPtr = NULL;
1245 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1246 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1247 stream->readback(checksumBufPtr, checksumSize);
1248 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1249 ALOGE("magma_buffer_get_cache_policy: GL communication error, please report this issue to b.android.com.\n");
1250 abort();
1251 }
1252 }
1253 return retval;
1254 }
1255
magma_buffer_set_name_enc(void * self,magma_buffer_t buffer,const char * name)1256 magma_status_t magma_buffer_set_name_enc(void *self , magma_buffer_t buffer, const char* name)
1257 {
1258 ENCODER_DEBUG_LOG("magma_buffer_set_name(buffer:%lu, name:%p)", buffer, name);
1259 AEMU_SCOPED_TRACE("magma_buffer_set_name encode");
1260
1261 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1262 IOStream *stream = ctx->m_stream;
1263 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1264 bool useChecksum = checksumCalculator->getVersion() > 0;
1265
1266 const unsigned int __size_name = 1;
1267 unsigned char *ptr;
1268 unsigned char *buf;
1269 const size_t sizeWithoutChecksum = 8 + 8 + __size_name + 1*4;
1270 const size_t checksumSize = checksumCalculator->checksumByteSize();
1271 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1272 buf = stream->alloc(totalSize);
1273 ptr = buf;
1274 int tmp = OP_magma_buffer_set_name;memcpy(ptr, &tmp, 4); ptr += 4;
1275 memcpy(ptr, &totalSize, 4); ptr += 4;
1276
1277 memcpy(ptr, &buffer, 8); ptr += 8;
1278 memcpy(ptr, &__size_name, 4); ptr += 4;
1279 memcpy(ptr, name, __size_name);ptr += __size_name;
1280
1281 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1282 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1283
1284
1285 magma_status_t retval;
1286 stream->readback(&retval, 4);
1287 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1288 if (useChecksum) {
1289 unsigned char *checksumBufPtr = NULL;
1290 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1291 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1292 stream->readback(checksumBufPtr, checksumSize);
1293 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1294 ALOGE("magma_buffer_set_name: GL communication error, please report this issue to b.android.com.\n");
1295 abort();
1296 }
1297 }
1298 return retval;
1299 }
1300
magma_buffer_set_name_fudge_enc(void * self,magma_buffer_t buffer,void * name,uint64_t name_size)1301 magma_status_t magma_buffer_set_name_fudge_enc(void *self , magma_buffer_t buffer, void* name, uint64_t name_size)
1302 {
1303 ENCODER_DEBUG_LOG("magma_buffer_set_name_fudge(buffer:%lu, name:%p, name_size:%lu)", buffer, name, name_size);
1304 AEMU_SCOPED_TRACE("magma_buffer_set_name_fudge encode");
1305
1306 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1307 IOStream *stream = ctx->m_stream;
1308 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1309 bool useChecksum = checksumCalculator->getVersion() > 0;
1310
1311 const unsigned int __size_name = name_size;
1312 unsigned char *ptr;
1313 unsigned char *buf;
1314 const size_t sizeWithoutChecksum = 8 + 8 + __size_name + 8 + 1*4;
1315 const size_t checksumSize = checksumCalculator->checksumByteSize();
1316 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1317 buf = stream->alloc(totalSize);
1318 ptr = buf;
1319 int tmp = OP_magma_buffer_set_name_fudge;memcpy(ptr, &tmp, 4); ptr += 4;
1320 memcpy(ptr, &totalSize, 4); ptr += 4;
1321
1322 memcpy(ptr, &buffer, 8); ptr += 8;
1323 memcpy(ptr, &__size_name, 4); ptr += 4;
1324 memcpy(ptr, name, __size_name);ptr += __size_name;
1325 memcpy(ptr, &name_size, 8); ptr += 8;
1326
1327 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1328 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1329
1330
1331 magma_status_t retval;
1332 stream->readback(&retval, 4);
1333 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1334 if (useChecksum) {
1335 unsigned char *checksumBufPtr = NULL;
1336 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1337 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1338 stream->readback(checksumBufPtr, checksumSize);
1339 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1340 ALOGE("magma_buffer_set_name_fudge: GL communication error, please report this issue to b.android.com.\n");
1341 abort();
1342 }
1343 }
1344 return retval;
1345 }
1346
magma_buffer_get_info_enc(void * self,magma_buffer_t buffer,magma_buffer_info_t * info_out)1347 magma_status_t magma_buffer_get_info_enc(void *self , magma_buffer_t buffer, magma_buffer_info_t* info_out)
1348 {
1349 ENCODER_DEBUG_LOG("magma_buffer_get_info(buffer:%lu, info_out:%p)", buffer, info_out);
1350 AEMU_SCOPED_TRACE("magma_buffer_get_info encode");
1351
1352 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1353 IOStream *stream = ctx->m_stream;
1354 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1355 bool useChecksum = checksumCalculator->getVersion() > 0;
1356
1357 const unsigned int __size_info_out = sizeof(magma_buffer_info);
1358 unsigned char *ptr;
1359 unsigned char *buf;
1360 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
1361 const size_t checksumSize = checksumCalculator->checksumByteSize();
1362 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1363 buf = stream->alloc(totalSize);
1364 ptr = buf;
1365 int tmp = OP_magma_buffer_get_info;memcpy(ptr, &tmp, 4); ptr += 4;
1366 memcpy(ptr, &totalSize, 4); ptr += 4;
1367
1368 memcpy(ptr, &buffer, 8); ptr += 8;
1369 memcpy(ptr, &__size_info_out, 4); ptr += 4;
1370
1371 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1372 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1373
1374 stream->readback(info_out, __size_info_out);
1375 if (useChecksum) checksumCalculator->addBuffer(info_out, __size_info_out);
1376
1377 magma_status_t retval;
1378 stream->readback(&retval, 4);
1379 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1380 if (useChecksum) {
1381 unsigned char *checksumBufPtr = NULL;
1382 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1383 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1384 stream->readback(checksumBufPtr, checksumSize);
1385 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1386 ALOGE("magma_buffer_get_info: GL communication error, please report this issue to b.android.com.\n");
1387 abort();
1388 }
1389 }
1390 return retval;
1391 }
1392
magma_buffer_get_handle_enc(void * self,magma_buffer_t buffer,magma_handle_t * handle_out)1393 magma_status_t magma_buffer_get_handle_enc(void *self , magma_buffer_t buffer, magma_handle_t* handle_out)
1394 {
1395 ENCODER_DEBUG_LOG("magma_buffer_get_handle(buffer:%lu, handle_out:%p)", buffer, handle_out);
1396 AEMU_SCOPED_TRACE("magma_buffer_get_handle encode");
1397
1398 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1399 IOStream *stream = ctx->m_stream;
1400 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1401 bool useChecksum = checksumCalculator->getVersion() > 0;
1402
1403 const unsigned int __size_handle_out = sizeof(magma_handle_t);
1404 unsigned char *ptr;
1405 unsigned char *buf;
1406 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
1407 const size_t checksumSize = checksumCalculator->checksumByteSize();
1408 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1409 buf = stream->alloc(totalSize);
1410 ptr = buf;
1411 int tmp = OP_magma_buffer_get_handle;memcpy(ptr, &tmp, 4); ptr += 4;
1412 memcpy(ptr, &totalSize, 4); ptr += 4;
1413
1414 memcpy(ptr, &buffer, 8); ptr += 8;
1415 memcpy(ptr, &__size_handle_out, 4); ptr += 4;
1416
1417 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1418 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1419
1420 stream->readback(handle_out, __size_handle_out);
1421 if (useChecksum) checksumCalculator->addBuffer(handle_out, __size_handle_out);
1422
1423 magma_status_t retval;
1424 stream->readback(&retval, 4);
1425 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1426 if (useChecksum) {
1427 unsigned char *checksumBufPtr = NULL;
1428 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1429 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1430 stream->readback(checksumBufPtr, checksumSize);
1431 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1432 ALOGE("magma_buffer_get_handle: GL communication error, please report this issue to b.android.com.\n");
1433 abort();
1434 }
1435 }
1436 return retval;
1437 }
1438
magma_buffer_export_enc(void * self,magma_buffer_t buffer,magma_handle_t * buffer_handle_out)1439 magma_status_t magma_buffer_export_enc(void *self , magma_buffer_t buffer, magma_handle_t* buffer_handle_out)
1440 {
1441 ENCODER_DEBUG_LOG("magma_buffer_export(buffer:%lu, buffer_handle_out:%p)", buffer, buffer_handle_out);
1442 AEMU_SCOPED_TRACE("magma_buffer_export encode");
1443
1444 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1445 IOStream *stream = ctx->m_stream;
1446 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1447 bool useChecksum = checksumCalculator->getVersion() > 0;
1448
1449 const unsigned int __size_buffer_handle_out = sizeof(magma_handle_t);
1450 unsigned char *ptr;
1451 unsigned char *buf;
1452 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
1453 const size_t checksumSize = checksumCalculator->checksumByteSize();
1454 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1455 buf = stream->alloc(totalSize);
1456 ptr = buf;
1457 int tmp = OP_magma_buffer_export;memcpy(ptr, &tmp, 4); ptr += 4;
1458 memcpy(ptr, &totalSize, 4); ptr += 4;
1459
1460 memcpy(ptr, &buffer, 8); ptr += 8;
1461 memcpy(ptr, &__size_buffer_handle_out, 4); ptr += 4;
1462
1463 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1464 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1465
1466 stream->readback(buffer_handle_out, __size_buffer_handle_out);
1467 if (useChecksum) checksumCalculator->addBuffer(buffer_handle_out, __size_buffer_handle_out);
1468
1469 magma_status_t retval;
1470 stream->readback(&retval, 4);
1471 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1472 if (useChecksum) {
1473 unsigned char *checksumBufPtr = NULL;
1474 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1475 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1476 stream->readback(checksumBufPtr, checksumSize);
1477 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1478 ALOGE("magma_buffer_export: GL communication error, please report this issue to b.android.com.\n");
1479 abort();
1480 }
1481 }
1482 return retval;
1483 }
1484
magma_semaphore_signal_enc(void * self,magma_semaphore_t semaphore)1485 void magma_semaphore_signal_enc(void *self , magma_semaphore_t semaphore)
1486 {
1487 ENCODER_DEBUG_LOG("magma_semaphore_signal(semaphore:%lu)", semaphore);
1488 AEMU_SCOPED_TRACE("magma_semaphore_signal encode");
1489
1490 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1491 IOStream *stream = ctx->m_stream;
1492 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1493 bool useChecksum = checksumCalculator->getVersion() > 0;
1494
1495 unsigned char *ptr;
1496 unsigned char *buf;
1497 const size_t sizeWithoutChecksum = 8 + 8;
1498 const size_t checksumSize = checksumCalculator->checksumByteSize();
1499 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1500 buf = stream->alloc(totalSize);
1501 ptr = buf;
1502 int tmp = OP_magma_semaphore_signal;memcpy(ptr, &tmp, 4); ptr += 4;
1503 memcpy(ptr, &totalSize, 4); ptr += 4;
1504
1505 memcpy(ptr, &semaphore, 8); ptr += 8;
1506
1507 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1508 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1509
1510 }
1511
magma_semaphore_reset_enc(void * self,magma_semaphore_t semaphore)1512 void magma_semaphore_reset_enc(void *self , magma_semaphore_t semaphore)
1513 {
1514 ENCODER_DEBUG_LOG("magma_semaphore_reset(semaphore:%lu)", semaphore);
1515 AEMU_SCOPED_TRACE("magma_semaphore_reset encode");
1516
1517 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1518 IOStream *stream = ctx->m_stream;
1519 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1520 bool useChecksum = checksumCalculator->getVersion() > 0;
1521
1522 unsigned char *ptr;
1523 unsigned char *buf;
1524 const size_t sizeWithoutChecksum = 8 + 8;
1525 const size_t checksumSize = checksumCalculator->checksumByteSize();
1526 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1527 buf = stream->alloc(totalSize);
1528 ptr = buf;
1529 int tmp = OP_magma_semaphore_reset;memcpy(ptr, &tmp, 4); ptr += 4;
1530 memcpy(ptr, &totalSize, 4); ptr += 4;
1531
1532 memcpy(ptr, &semaphore, 8); ptr += 8;
1533
1534 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1535 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1536
1537 }
1538
magma_semaphore_export_enc(void * self,magma_semaphore_t semaphore,magma_handle_t * semaphore_handle_out)1539 magma_status_t magma_semaphore_export_enc(void *self , magma_semaphore_t semaphore, magma_handle_t* semaphore_handle_out)
1540 {
1541 ENCODER_DEBUG_LOG("magma_semaphore_export(semaphore:%lu, semaphore_handle_out:%p)", semaphore, semaphore_handle_out);
1542 AEMU_SCOPED_TRACE("magma_semaphore_export encode");
1543
1544 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1545 IOStream *stream = ctx->m_stream;
1546 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1547 bool useChecksum = checksumCalculator->getVersion() > 0;
1548
1549 const unsigned int __size_semaphore_handle_out = sizeof(magma_handle_t);
1550 unsigned char *ptr;
1551 unsigned char *buf;
1552 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
1553 const size_t checksumSize = checksumCalculator->checksumByteSize();
1554 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1555 buf = stream->alloc(totalSize);
1556 ptr = buf;
1557 int tmp = OP_magma_semaphore_export;memcpy(ptr, &tmp, 4); ptr += 4;
1558 memcpy(ptr, &totalSize, 4); ptr += 4;
1559
1560 memcpy(ptr, &semaphore, 8); ptr += 8;
1561 memcpy(ptr, &__size_semaphore_handle_out, 4); ptr += 4;
1562
1563 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1564 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1565
1566 stream->readback(semaphore_handle_out, __size_semaphore_handle_out);
1567 if (useChecksum) checksumCalculator->addBuffer(semaphore_handle_out, __size_semaphore_handle_out);
1568
1569 magma_status_t retval;
1570 stream->readback(&retval, 4);
1571 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1572 if (useChecksum) {
1573 unsigned char *checksumBufPtr = NULL;
1574 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1575 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1576 stream->readback(checksumBufPtr, checksumSize);
1577 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1578 ALOGE("magma_semaphore_export: GL communication error, please report this issue to b.android.com.\n");
1579 abort();
1580 }
1581 }
1582 return retval;
1583 }
1584
magma_poll_enc(void * self,magma_poll_item_t * items,uint32_t count,uint64_t timeout_ns)1585 magma_status_t magma_poll_enc(void *self , magma_poll_item_t* items, uint32_t count, uint64_t timeout_ns)
1586 {
1587 ENCODER_DEBUG_LOG("magma_poll(items:%p, count:%u, timeout_ns:%lu)", items, count, timeout_ns);
1588 AEMU_SCOPED_TRACE("magma_poll encode");
1589
1590 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1591 IOStream *stream = ctx->m_stream;
1592 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1593 bool useChecksum = checksumCalculator->getVersion() > 0;
1594
1595 const unsigned int __size_items = count * sizeof(magma_poll_item_t);
1596 unsigned char *ptr;
1597 unsigned char *buf;
1598 const size_t sizeWithoutChecksum = 8 + __size_items + 4 + 8 + 1*4;
1599 const size_t checksumSize = checksumCalculator->checksumByteSize();
1600 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1601 buf = stream->alloc(totalSize);
1602 ptr = buf;
1603 int tmp = OP_magma_poll;memcpy(ptr, &tmp, 4); ptr += 4;
1604 memcpy(ptr, &totalSize, 4); ptr += 4;
1605
1606 memcpy(ptr, &__size_items, 4); ptr += 4;
1607 memcpy(ptr, items, __size_items);ptr += __size_items;
1608 memcpy(ptr, &count, 4); ptr += 4;
1609 memcpy(ptr, &timeout_ns, 8); ptr += 8;
1610
1611 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1612 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1613
1614 stream->readback(items, __size_items);
1615 if (useChecksum) checksumCalculator->addBuffer(items, __size_items);
1616
1617 magma_status_t retval;
1618 stream->readback(&retval, 4);
1619 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1620 if (useChecksum) {
1621 unsigned char *checksumBufPtr = NULL;
1622 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1623 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1624 stream->readback(checksumBufPtr, checksumSize);
1625 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1626 ALOGE("magma_poll: GL communication error, please report this issue to b.android.com.\n");
1627 abort();
1628 }
1629 }
1630 return retval;
1631 }
1632
magma_initialize_tracing_enc(void * self,magma_handle_t channel)1633 magma_status_t magma_initialize_tracing_enc(void *self , magma_handle_t channel)
1634 {
1635 ENCODER_DEBUG_LOG("magma_initialize_tracing(channel:%u)", channel);
1636 AEMU_SCOPED_TRACE("magma_initialize_tracing encode");
1637
1638 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1639 IOStream *stream = ctx->m_stream;
1640 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1641 bool useChecksum = checksumCalculator->getVersion() > 0;
1642
1643 unsigned char *ptr;
1644 unsigned char *buf;
1645 const size_t sizeWithoutChecksum = 8 + 4;
1646 const size_t checksumSize = checksumCalculator->checksumByteSize();
1647 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1648 buf = stream->alloc(totalSize);
1649 ptr = buf;
1650 int tmp = OP_magma_initialize_tracing;memcpy(ptr, &tmp, 4); ptr += 4;
1651 memcpy(ptr, &totalSize, 4); ptr += 4;
1652
1653 memcpy(ptr, &channel, 4); ptr += 4;
1654
1655 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1656 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1657
1658
1659 magma_status_t retval;
1660 stream->readback(&retval, 4);
1661 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1662 if (useChecksum) {
1663 unsigned char *checksumBufPtr = NULL;
1664 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1665 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1666 stream->readback(checksumBufPtr, checksumSize);
1667 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1668 ALOGE("magma_initialize_tracing: GL communication error, please report this issue to b.android.com.\n");
1669 abort();
1670 }
1671 }
1672 return retval;
1673 }
1674
magma_initialize_logging_enc(void * self,magma_handle_t channel)1675 magma_status_t magma_initialize_logging_enc(void *self , magma_handle_t channel)
1676 {
1677 ENCODER_DEBUG_LOG("magma_initialize_logging(channel:%u)", channel);
1678 AEMU_SCOPED_TRACE("magma_initialize_logging encode");
1679
1680 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1681 IOStream *stream = ctx->m_stream;
1682 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1683 bool useChecksum = checksumCalculator->getVersion() > 0;
1684
1685 unsigned char *ptr;
1686 unsigned char *buf;
1687 const size_t sizeWithoutChecksum = 8 + 4;
1688 const size_t checksumSize = checksumCalculator->checksumByteSize();
1689 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1690 buf = stream->alloc(totalSize);
1691 ptr = buf;
1692 int tmp = OP_magma_initialize_logging;memcpy(ptr, &tmp, 4); ptr += 4;
1693 memcpy(ptr, &totalSize, 4); ptr += 4;
1694
1695 memcpy(ptr, &channel, 4); ptr += 4;
1696
1697 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1698 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1699
1700
1701 magma_status_t retval;
1702 stream->readback(&retval, 4);
1703 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1704 if (useChecksum) {
1705 unsigned char *checksumBufPtr = NULL;
1706 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1707 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1708 stream->readback(checksumBufPtr, checksumSize);
1709 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1710 ALOGE("magma_initialize_logging: GL communication error, please report this issue to b.android.com.\n");
1711 abort();
1712 }
1713 }
1714 return retval;
1715 }
1716
magma_connection_enable_performance_counter_access_enc(void * self,magma_connection_t connection,magma_handle_t channel)1717 magma_status_t magma_connection_enable_performance_counter_access_enc(void *self , magma_connection_t connection, magma_handle_t channel)
1718 {
1719 ENCODER_DEBUG_LOG("magma_connection_enable_performance_counter_access(connection:%lu, channel:%u)", connection, channel);
1720 AEMU_SCOPED_TRACE("magma_connection_enable_performance_counter_access encode");
1721
1722 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1723 IOStream *stream = ctx->m_stream;
1724 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1725 bool useChecksum = checksumCalculator->getVersion() > 0;
1726
1727 unsigned char *ptr;
1728 unsigned char *buf;
1729 const size_t sizeWithoutChecksum = 8 + 8 + 4;
1730 const size_t checksumSize = checksumCalculator->checksumByteSize();
1731 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1732 buf = stream->alloc(totalSize);
1733 ptr = buf;
1734 int tmp = OP_magma_connection_enable_performance_counter_access;memcpy(ptr, &tmp, 4); ptr += 4;
1735 memcpy(ptr, &totalSize, 4); ptr += 4;
1736
1737 memcpy(ptr, &connection, 8); ptr += 8;
1738 memcpy(ptr, &channel, 4); ptr += 4;
1739
1740 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1741 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1742
1743
1744 magma_status_t retval;
1745 stream->readback(&retval, 4);
1746 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1747 if (useChecksum) {
1748 unsigned char *checksumBufPtr = NULL;
1749 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1750 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1751 stream->readback(checksumBufPtr, checksumSize);
1752 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1753 ALOGE("magma_connection_enable_performance_counter_access: GL communication error, please report this issue to b.android.com.\n");
1754 abort();
1755 }
1756 }
1757 return retval;
1758 }
1759
magma_connection_enable_performance_counters_enc(void * self,magma_connection_t connection,uint64_t * counters,uint64_t counters_count)1760 magma_status_t magma_connection_enable_performance_counters_enc(void *self , magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
1761 {
1762 ENCODER_DEBUG_LOG("magma_connection_enable_performance_counters(connection:%lu, counters:%p, counters_count:%lu)", connection, counters, counters_count);
1763 AEMU_SCOPED_TRACE("magma_connection_enable_performance_counters encode");
1764
1765 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1766 IOStream *stream = ctx->m_stream;
1767 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1768 bool useChecksum = checksumCalculator->getVersion() > 0;
1769
1770 const unsigned int __size_counters = counters_count * sizeof(uint64_t);
1771 unsigned char *ptr;
1772 unsigned char *buf;
1773 const size_t sizeWithoutChecksum = 8 + 8 + __size_counters + 8 + 1*4;
1774 const size_t checksumSize = checksumCalculator->checksumByteSize();
1775 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1776 buf = stream->alloc(totalSize);
1777 ptr = buf;
1778 int tmp = OP_magma_connection_enable_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
1779 memcpy(ptr, &totalSize, 4); ptr += 4;
1780
1781 memcpy(ptr, &connection, 8); ptr += 8;
1782 memcpy(ptr, &__size_counters, 4); ptr += 4;
1783 memcpy(ptr, counters, __size_counters);ptr += __size_counters;
1784 memcpy(ptr, &counters_count, 8); ptr += 8;
1785
1786 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1787 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1788
1789
1790 magma_status_t retval;
1791 stream->readback(&retval, 4);
1792 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1793 if (useChecksum) {
1794 unsigned char *checksumBufPtr = NULL;
1795 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1796 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1797 stream->readback(checksumBufPtr, checksumSize);
1798 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1799 ALOGE("magma_connection_enable_performance_counters: GL communication error, please report this issue to b.android.com.\n");
1800 abort();
1801 }
1802 }
1803 return retval;
1804 }
1805
magma_connection_create_performance_counter_buffer_pool_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t * pool_id_out,magma_handle_t * notification_handle_out)1806 magma_status_t magma_connection_create_performance_counter_buffer_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t* pool_id_out, magma_handle_t* notification_handle_out)
1807 {
1808 ENCODER_DEBUG_LOG("magma_connection_create_performance_counter_buffer_pool(connection:%lu, pool_id_out:%p, notification_handle_out:%p)", connection, pool_id_out, notification_handle_out);
1809 AEMU_SCOPED_TRACE("magma_connection_create_performance_counter_buffer_pool encode");
1810
1811 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1812 IOStream *stream = ctx->m_stream;
1813 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1814 bool useChecksum = checksumCalculator->getVersion() > 0;
1815
1816 const unsigned int __size_pool_id_out = sizeof(magma_perf_count_pool_t);
1817 const unsigned int __size_notification_handle_out = sizeof(magma_handle_t);
1818 unsigned char *ptr;
1819 unsigned char *buf;
1820 const size_t sizeWithoutChecksum = 8 + 8 + 0 + 0 + 2*4;
1821 const size_t checksumSize = checksumCalculator->checksumByteSize();
1822 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1823 buf = stream->alloc(totalSize);
1824 ptr = buf;
1825 int tmp = OP_magma_connection_create_performance_counter_buffer_pool;memcpy(ptr, &tmp, 4); ptr += 4;
1826 memcpy(ptr, &totalSize, 4); ptr += 4;
1827
1828 memcpy(ptr, &connection, 8); ptr += 8;
1829 memcpy(ptr, &__size_pool_id_out, 4); ptr += 4;
1830 memcpy(ptr, &__size_notification_handle_out, 4); ptr += 4;
1831
1832 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1833 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1834
1835 stream->readback(pool_id_out, __size_pool_id_out);
1836 if (useChecksum) checksumCalculator->addBuffer(pool_id_out, __size_pool_id_out);
1837 stream->readback(notification_handle_out, __size_notification_handle_out);
1838 if (useChecksum) checksumCalculator->addBuffer(notification_handle_out, __size_notification_handle_out);
1839
1840 magma_status_t retval;
1841 stream->readback(&retval, 4);
1842 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1843 if (useChecksum) {
1844 unsigned char *checksumBufPtr = NULL;
1845 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1846 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1847 stream->readback(checksumBufPtr, checksumSize);
1848 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1849 ALOGE("magma_connection_create_performance_counter_buffer_pool: GL communication error, please report this issue to b.android.com.\n");
1850 abort();
1851 }
1852 }
1853 return retval;
1854 }
1855
magma_connection_release_performance_counter_buffer_pool_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t pool_id)1856 magma_status_t magma_connection_release_performance_counter_buffer_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id)
1857 {
1858 ENCODER_DEBUG_LOG("magma_connection_release_performance_counter_buffer_pool(connection:%lu, pool_id:%lu)", connection, pool_id);
1859 AEMU_SCOPED_TRACE("magma_connection_release_performance_counter_buffer_pool encode");
1860
1861 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1862 IOStream *stream = ctx->m_stream;
1863 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1864 bool useChecksum = checksumCalculator->getVersion() > 0;
1865
1866 unsigned char *ptr;
1867 unsigned char *buf;
1868 const size_t sizeWithoutChecksum = 8 + 8 + 8;
1869 const size_t checksumSize = checksumCalculator->checksumByteSize();
1870 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1871 buf = stream->alloc(totalSize);
1872 ptr = buf;
1873 int tmp = OP_magma_connection_release_performance_counter_buffer_pool;memcpy(ptr, &tmp, 4); ptr += 4;
1874 memcpy(ptr, &totalSize, 4); ptr += 4;
1875
1876 memcpy(ptr, &connection, 8); ptr += 8;
1877 memcpy(ptr, &pool_id, 8); ptr += 8;
1878
1879 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1880 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1881
1882
1883 magma_status_t retval;
1884 stream->readback(&retval, 4);
1885 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1886 if (useChecksum) {
1887 unsigned char *checksumBufPtr = NULL;
1888 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1889 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1890 stream->readback(checksumBufPtr, checksumSize);
1891 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1892 ALOGE("magma_connection_release_performance_counter_buffer_pool: GL communication error, please report this issue to b.android.com.\n");
1893 abort();
1894 }
1895 }
1896 return retval;
1897 }
1898
magma_connection_add_performance_counter_buffer_offsets_to_pool_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t pool_id,const magma_buffer_offset_t * offsets,uint64_t offsets_count)1899 magma_status_t magma_connection_add_performance_counter_buffer_offsets_to_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, const magma_buffer_offset_t* offsets, uint64_t offsets_count)
1900 {
1901 ENCODER_DEBUG_LOG("magma_connection_add_performance_counter_buffer_offsets_to_pool(connection:%lu, pool_id:%lu, offsets:%p, offsets_count:%lu)", connection, pool_id, offsets, offsets_count);
1902 AEMU_SCOPED_TRACE("magma_connection_add_performance_counter_buffer_offsets_to_pool encode");
1903
1904 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1905 IOStream *stream = ctx->m_stream;
1906 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1907 bool useChecksum = checksumCalculator->getVersion() > 0;
1908
1909 const unsigned int __size_offsets = offsets_count * sizeof(magma_buffer_offset_t);
1910 unsigned char *ptr;
1911 unsigned char *buf;
1912 const size_t sizeWithoutChecksum = 8 + 8 + 8 + __size_offsets + 8 + 1*4;
1913 const size_t checksumSize = checksumCalculator->checksumByteSize();
1914 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1915 buf = stream->alloc(totalSize);
1916 ptr = buf;
1917 int tmp = OP_magma_connection_add_performance_counter_buffer_offsets_to_pool;memcpy(ptr, &tmp, 4); ptr += 4;
1918 memcpy(ptr, &totalSize, 4); ptr += 4;
1919
1920 memcpy(ptr, &connection, 8); ptr += 8;
1921 memcpy(ptr, &pool_id, 8); ptr += 8;
1922 memcpy(ptr, &__size_offsets, 4); ptr += 4;
1923 memcpy(ptr, offsets, __size_offsets);ptr += __size_offsets;
1924 memcpy(ptr, &offsets_count, 8); ptr += 8;
1925
1926 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1927 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1928
1929
1930 magma_status_t retval;
1931 stream->readback(&retval, 4);
1932 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1933 if (useChecksum) {
1934 unsigned char *checksumBufPtr = NULL;
1935 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1936 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1937 stream->readback(checksumBufPtr, checksumSize);
1938 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1939 ALOGE("magma_connection_add_performance_counter_buffer_offsets_to_pool: GL communication error, please report this issue to b.android.com.\n");
1940 abort();
1941 }
1942 }
1943 return retval;
1944 }
1945
magma_connection_remove_performance_counter_buffer_from_pool_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t pool_id,magma_buffer_t buffer)1946 magma_status_t magma_connection_remove_performance_counter_buffer_from_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, magma_buffer_t buffer)
1947 {
1948 ENCODER_DEBUG_LOG("magma_connection_remove_performance_counter_buffer_from_pool(connection:%lu, pool_id:%lu, buffer:%lu)", connection, pool_id, buffer);
1949 AEMU_SCOPED_TRACE("magma_connection_remove_performance_counter_buffer_from_pool encode");
1950
1951 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1952 IOStream *stream = ctx->m_stream;
1953 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1954 bool useChecksum = checksumCalculator->getVersion() > 0;
1955
1956 unsigned char *ptr;
1957 unsigned char *buf;
1958 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8;
1959 const size_t checksumSize = checksumCalculator->checksumByteSize();
1960 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1961 buf = stream->alloc(totalSize);
1962 ptr = buf;
1963 int tmp = OP_magma_connection_remove_performance_counter_buffer_from_pool;memcpy(ptr, &tmp, 4); ptr += 4;
1964 memcpy(ptr, &totalSize, 4); ptr += 4;
1965
1966 memcpy(ptr, &connection, 8); ptr += 8;
1967 memcpy(ptr, &pool_id, 8); ptr += 8;
1968 memcpy(ptr, &buffer, 8); ptr += 8;
1969
1970 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1971 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1972
1973
1974 magma_status_t retval;
1975 stream->readback(&retval, 4);
1976 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1977 if (useChecksum) {
1978 unsigned char *checksumBufPtr = NULL;
1979 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1980 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1981 stream->readback(checksumBufPtr, checksumSize);
1982 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1983 ALOGE("magma_connection_remove_performance_counter_buffer_from_pool: GL communication error, please report this issue to b.android.com.\n");
1984 abort();
1985 }
1986 }
1987 return retval;
1988 }
1989
magma_connection_dump_performance_counters_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t pool_id,uint32_t trigger_id)1990 magma_status_t magma_connection_dump_performance_counters_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t trigger_id)
1991 {
1992 ENCODER_DEBUG_LOG("magma_connection_dump_performance_counters(connection:%lu, pool_id:%lu, trigger_id:%u)", connection, pool_id, trigger_id);
1993 AEMU_SCOPED_TRACE("magma_connection_dump_performance_counters encode");
1994
1995 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
1996 IOStream *stream = ctx->m_stream;
1997 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1998 bool useChecksum = checksumCalculator->getVersion() > 0;
1999
2000 unsigned char *ptr;
2001 unsigned char *buf;
2002 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 4;
2003 const size_t checksumSize = checksumCalculator->checksumByteSize();
2004 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2005 buf = stream->alloc(totalSize);
2006 ptr = buf;
2007 int tmp = OP_magma_connection_dump_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
2008 memcpy(ptr, &totalSize, 4); ptr += 4;
2009
2010 memcpy(ptr, &connection, 8); ptr += 8;
2011 memcpy(ptr, &pool_id, 8); ptr += 8;
2012 memcpy(ptr, &trigger_id, 4); ptr += 4;
2013
2014 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2015 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2016
2017
2018 magma_status_t retval;
2019 stream->readback(&retval, 4);
2020 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2021 if (useChecksum) {
2022 unsigned char *checksumBufPtr = NULL;
2023 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2024 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2025 stream->readback(checksumBufPtr, checksumSize);
2026 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2027 ALOGE("magma_connection_dump_performance_counters: GL communication error, please report this issue to b.android.com.\n");
2028 abort();
2029 }
2030 }
2031 return retval;
2032 }
2033
magma_connection_clear_performance_counters_enc(void * self,magma_connection_t connection,uint64_t * counters,uint64_t counters_count)2034 magma_status_t magma_connection_clear_performance_counters_enc(void *self , magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
2035 {
2036 ENCODER_DEBUG_LOG("magma_connection_clear_performance_counters(connection:%lu, counters:%p, counters_count:%lu)", connection, counters, counters_count);
2037 AEMU_SCOPED_TRACE("magma_connection_clear_performance_counters encode");
2038
2039 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
2040 IOStream *stream = ctx->m_stream;
2041 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2042 bool useChecksum = checksumCalculator->getVersion() > 0;
2043
2044 const unsigned int __size_counters = counters_count * sizeof(uint64_t);
2045 unsigned char *ptr;
2046 unsigned char *buf;
2047 const size_t sizeWithoutChecksum = 8 + 8 + __size_counters + 8 + 1*4;
2048 const size_t checksumSize = checksumCalculator->checksumByteSize();
2049 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2050 buf = stream->alloc(totalSize);
2051 ptr = buf;
2052 int tmp = OP_magma_connection_clear_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
2053 memcpy(ptr, &totalSize, 4); ptr += 4;
2054
2055 memcpy(ptr, &connection, 8); ptr += 8;
2056 memcpy(ptr, &__size_counters, 4); ptr += 4;
2057 memcpy(ptr, counters, __size_counters);ptr += __size_counters;
2058 memcpy(ptr, &counters_count, 8); ptr += 8;
2059
2060 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2061 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2062
2063
2064 magma_status_t retval;
2065 stream->readback(&retval, 4);
2066 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2067 if (useChecksum) {
2068 unsigned char *checksumBufPtr = NULL;
2069 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2070 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2071 stream->readback(checksumBufPtr, checksumSize);
2072 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2073 ALOGE("magma_connection_clear_performance_counters: GL communication error, please report this issue to b.android.com.\n");
2074 abort();
2075 }
2076 }
2077 return retval;
2078 }
2079
magma_connection_read_performance_counter_completion_enc(void * self,magma_connection_t connection,magma_perf_count_pool_t pool_id,uint32_t * trigger_id_out,uint64_t * buffer_id_out,uint32_t * buffer_offset_out,uint64_t * time_out,uint32_t * result_flags_out)2080 magma_status_t magma_connection_read_performance_counter_completion_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t* trigger_id_out, uint64_t* buffer_id_out, uint32_t* buffer_offset_out, uint64_t* time_out, uint32_t* result_flags_out)
2081 {
2082 ENCODER_DEBUG_LOG("magma_connection_read_performance_counter_completion(connection:%lu, pool_id:%lu, trigger_id_out:%p, buffer_id_out:%p, buffer_offset_out:%p, time_out:%p, result_flags_out:%p)", connection, pool_id, trigger_id_out, buffer_id_out, buffer_offset_out, time_out, result_flags_out);
2083 AEMU_SCOPED_TRACE("magma_connection_read_performance_counter_completion encode");
2084
2085 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
2086 IOStream *stream = ctx->m_stream;
2087 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2088 bool useChecksum = checksumCalculator->getVersion() > 0;
2089
2090 const unsigned int __size_trigger_id_out = sizeof(uint32_t);
2091 const unsigned int __size_buffer_id_out = sizeof(uint64_t);
2092 const unsigned int __size_buffer_offset_out = sizeof(uint32_t);
2093 const unsigned int __size_time_out = sizeof(uint64_t);
2094 const unsigned int __size_result_flags_out = sizeof(uint32_t);
2095 unsigned char *ptr;
2096 unsigned char *buf;
2097 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 0 + 0 + 0 + 5*4;
2098 const size_t checksumSize = checksumCalculator->checksumByteSize();
2099 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2100 buf = stream->alloc(totalSize);
2101 ptr = buf;
2102 int tmp = OP_magma_connection_read_performance_counter_completion;memcpy(ptr, &tmp, 4); ptr += 4;
2103 memcpy(ptr, &totalSize, 4); ptr += 4;
2104
2105 memcpy(ptr, &connection, 8); ptr += 8;
2106 memcpy(ptr, &pool_id, 8); ptr += 8;
2107 memcpy(ptr, &__size_trigger_id_out, 4); ptr += 4;
2108 memcpy(ptr, &__size_buffer_id_out, 4); ptr += 4;
2109 memcpy(ptr, &__size_buffer_offset_out, 4); ptr += 4;
2110 memcpy(ptr, &__size_time_out, 4); ptr += 4;
2111 memcpy(ptr, &__size_result_flags_out, 4); ptr += 4;
2112
2113 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2114 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2115
2116 stream->readback(trigger_id_out, __size_trigger_id_out);
2117 if (useChecksum) checksumCalculator->addBuffer(trigger_id_out, __size_trigger_id_out);
2118 stream->readback(buffer_id_out, __size_buffer_id_out);
2119 if (useChecksum) checksumCalculator->addBuffer(buffer_id_out, __size_buffer_id_out);
2120 stream->readback(buffer_offset_out, __size_buffer_offset_out);
2121 if (useChecksum) checksumCalculator->addBuffer(buffer_offset_out, __size_buffer_offset_out);
2122 stream->readback(time_out, __size_time_out);
2123 if (useChecksum) checksumCalculator->addBuffer(time_out, __size_time_out);
2124 stream->readback(result_flags_out, __size_result_flags_out);
2125 if (useChecksum) checksumCalculator->addBuffer(result_flags_out, __size_result_flags_out);
2126
2127 magma_status_t retval;
2128 stream->readback(&retval, 4);
2129 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2130 if (useChecksum) {
2131 unsigned char *checksumBufPtr = NULL;
2132 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2133 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2134 stream->readback(checksumBufPtr, checksumSize);
2135 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2136 ALOGE("magma_connection_read_performance_counter_completion: GL communication error, please report this issue to b.android.com.\n");
2137 abort();
2138 }
2139 }
2140 return retval;
2141 }
2142
magma_virt_connection_create_image_enc(void * self,magma_connection_t connection,magma_image_create_info_t * create_info,uint64_t * size_out,magma_buffer_t * image_out,magma_buffer_id_t * buffer_id_out)2143 magma_status_t magma_virt_connection_create_image_enc(void *self , magma_connection_t connection, magma_image_create_info_t* create_info, uint64_t* size_out, magma_buffer_t* image_out, magma_buffer_id_t* buffer_id_out)
2144 {
2145 ENCODER_DEBUG_LOG("magma_virt_connection_create_image(connection:%lu, create_info:%p, size_out:%p, image_out:%p, buffer_id_out:%p)", connection, create_info, size_out, image_out, buffer_id_out);
2146 AEMU_SCOPED_TRACE("magma_virt_connection_create_image encode");
2147
2148 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
2149 IOStream *stream = ctx->m_stream;
2150 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2151 bool useChecksum = checksumCalculator->getVersion() > 0;
2152
2153 const unsigned int __size_create_info = sizeof(magma_image_create_info_t);
2154 const unsigned int __size_size_out = sizeof(uint64_t);
2155 const unsigned int __size_image_out = sizeof(magma_buffer_t);
2156 const unsigned int __size_buffer_id_out = sizeof(magma_buffer_id_t);
2157 unsigned char *ptr;
2158 unsigned char *buf;
2159 const size_t sizeWithoutChecksum = 8 + 8 + __size_create_info + 0 + 0 + 0 + 4*4;
2160 const size_t checksumSize = checksumCalculator->checksumByteSize();
2161 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2162 buf = stream->alloc(totalSize);
2163 ptr = buf;
2164 int tmp = OP_magma_virt_connection_create_image;memcpy(ptr, &tmp, 4); ptr += 4;
2165 memcpy(ptr, &totalSize, 4); ptr += 4;
2166
2167 memcpy(ptr, &connection, 8); ptr += 8;
2168 memcpy(ptr, &__size_create_info, 4); ptr += 4;
2169 memcpy(ptr, create_info, __size_create_info);ptr += __size_create_info;
2170 memcpy(ptr, &__size_size_out, 4); ptr += 4;
2171 memcpy(ptr, &__size_image_out, 4); ptr += 4;
2172 memcpy(ptr, &__size_buffer_id_out, 4); ptr += 4;
2173
2174 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2175 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2176
2177 stream->readback(size_out, __size_size_out);
2178 if (useChecksum) checksumCalculator->addBuffer(size_out, __size_size_out);
2179 stream->readback(image_out, __size_image_out);
2180 if (useChecksum) checksumCalculator->addBuffer(image_out, __size_image_out);
2181 stream->readback(buffer_id_out, __size_buffer_id_out);
2182 if (useChecksum) checksumCalculator->addBuffer(buffer_id_out, __size_buffer_id_out);
2183
2184 magma_status_t retval;
2185 stream->readback(&retval, 4);
2186 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2187 if (useChecksum) {
2188 unsigned char *checksumBufPtr = NULL;
2189 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2190 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2191 stream->readback(checksumBufPtr, checksumSize);
2192 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2193 ALOGE("magma_virt_connection_create_image: GL communication error, please report this issue to b.android.com.\n");
2194 abort();
2195 }
2196 }
2197 return retval;
2198 }
2199
magma_virt_connection_get_image_info_enc(void * self,magma_connection_t connection,magma_buffer_t image,magma_image_info_t * image_info_out)2200 magma_status_t magma_virt_connection_get_image_info_enc(void *self , magma_connection_t connection, magma_buffer_t image, magma_image_info_t* image_info_out)
2201 {
2202 ENCODER_DEBUG_LOG("magma_virt_connection_get_image_info(connection:%lu, image:%lu, image_info_out:%p)", connection, image, image_info_out);
2203 AEMU_SCOPED_TRACE("magma_virt_connection_get_image_info encode");
2204
2205 magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
2206 IOStream *stream = ctx->m_stream;
2207 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2208 bool useChecksum = checksumCalculator->getVersion() > 0;
2209
2210 const unsigned int __size_image_info_out = sizeof(magma_image_info_t);
2211 unsigned char *ptr;
2212 unsigned char *buf;
2213 const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 1*4;
2214 const size_t checksumSize = checksumCalculator->checksumByteSize();
2215 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2216 buf = stream->alloc(totalSize);
2217 ptr = buf;
2218 int tmp = OP_magma_virt_connection_get_image_info;memcpy(ptr, &tmp, 4); ptr += 4;
2219 memcpy(ptr, &totalSize, 4); ptr += 4;
2220
2221 memcpy(ptr, &connection, 8); ptr += 8;
2222 memcpy(ptr, &image, 8); ptr += 8;
2223 memcpy(ptr, &__size_image_info_out, 4); ptr += 4;
2224
2225 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2226 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2227
2228 stream->readback(image_info_out, __size_image_info_out);
2229 if (useChecksum) checksumCalculator->addBuffer(image_info_out, __size_image_info_out);
2230
2231 magma_status_t retval;
2232 stream->readback(&retval, 4);
2233 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2234 if (useChecksum) {
2235 unsigned char *checksumBufPtr = NULL;
2236 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2237 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2238 stream->readback(checksumBufPtr, checksumSize);
2239 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2240 ALOGE("magma_virt_connection_get_image_info: GL communication error, please report this issue to b.android.com.\n");
2241 abort();
2242 }
2243 }
2244 return retval;
2245 }
2246
2247 } // namespace
2248
magma_encoder_context_t(IOStream * stream,ChecksumCalculator * checksumCalculator)2249 magma_encoder_context_t::magma_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
2250 {
2251 m_stream = stream;
2252 m_checksumCalculator = checksumCalculator;
2253
2254 this->magma_device_import = &magma_device_import_enc;
2255 this->magma_device_release = &magma_device_release_enc;
2256 this->magma_device_query = &magma_device_query_enc;
2257 this->magma_device_query_fudge = &magma_device_query_fudge_enc;
2258 this->magma_device_create_connection = &magma_device_create_connection_enc;
2259 this->magma_connection_release = &magma_connection_release_enc;
2260 this->magma_connection_get_error = &magma_connection_get_error_enc;
2261 this->magma_connection_create_context = &magma_connection_create_context_enc;
2262 this->magma_connection_release_context = &magma_connection_release_context_enc;
2263 this->magma_connection_create_buffer = &magma_connection_create_buffer_enc;
2264 this->magma_connection_release_buffer = &magma_connection_release_buffer_enc;
2265 this->magma_connection_import_buffer = &magma_connection_import_buffer_enc;
2266 this->magma_connection_create_semaphore = &magma_connection_create_semaphore_enc;
2267 this->magma_connection_release_semaphore = &magma_connection_release_semaphore_enc;
2268 this->magma_connection_import_semaphore = &magma_connection_import_semaphore_enc;
2269 this->magma_connection_perform_buffer_op = &magma_connection_perform_buffer_op_enc;
2270 this->magma_connection_map_buffer = &magma_connection_map_buffer_enc;
2271 this->magma_connection_unmap_buffer = &magma_connection_unmap_buffer_enc;
2272 this->magma_connection_execute_command = &magma_connection_execute_command_enc;
2273 this->magma_connection_execute_command_fudge = &magma_connection_execute_command_fudge_enc;
2274 this->magma_connection_execute_immediate_commands = &magma_connection_execute_immediate_commands_enc;
2275 this->magma_connection_execute_immediate_commands_fudge = &magma_connection_execute_immediate_commands_fudge_enc;
2276 this->magma_connection_flush = &magma_connection_flush_enc;
2277 this->magma_connection_get_notification_channel_handle = &magma_connection_get_notification_channel_handle_enc;
2278 this->magma_connection_read_notification_channel = &magma_connection_read_notification_channel_enc;
2279 this->magma_buffer_clean_cache = &magma_buffer_clean_cache_enc;
2280 this->magma_buffer_set_cache_policy = &magma_buffer_set_cache_policy_enc;
2281 this->magma_buffer_get_cache_policy = &magma_buffer_get_cache_policy_enc;
2282 this->magma_buffer_set_name = &magma_buffer_set_name_enc;
2283 this->magma_buffer_set_name_fudge = &magma_buffer_set_name_fudge_enc;
2284 this->magma_buffer_get_info = &magma_buffer_get_info_enc;
2285 this->magma_buffer_get_handle = &magma_buffer_get_handle_enc;
2286 this->magma_buffer_export = &magma_buffer_export_enc;
2287 this->magma_semaphore_signal = &magma_semaphore_signal_enc;
2288 this->magma_semaphore_reset = &magma_semaphore_reset_enc;
2289 this->magma_semaphore_export = &magma_semaphore_export_enc;
2290 this->magma_poll = &magma_poll_enc;
2291 this->magma_initialize_tracing = &magma_initialize_tracing_enc;
2292 this->magma_initialize_logging = &magma_initialize_logging_enc;
2293 this->magma_connection_enable_performance_counter_access = &magma_connection_enable_performance_counter_access_enc;
2294 this->magma_connection_enable_performance_counters = &magma_connection_enable_performance_counters_enc;
2295 this->magma_connection_create_performance_counter_buffer_pool = &magma_connection_create_performance_counter_buffer_pool_enc;
2296 this->magma_connection_release_performance_counter_buffer_pool = &magma_connection_release_performance_counter_buffer_pool_enc;
2297 this->magma_connection_add_performance_counter_buffer_offsets_to_pool = &magma_connection_add_performance_counter_buffer_offsets_to_pool_enc;
2298 this->magma_connection_remove_performance_counter_buffer_from_pool = &magma_connection_remove_performance_counter_buffer_from_pool_enc;
2299 this->magma_connection_dump_performance_counters = &magma_connection_dump_performance_counters_enc;
2300 this->magma_connection_clear_performance_counters = &magma_connection_clear_performance_counters_enc;
2301 this->magma_connection_read_performance_counter_completion = &magma_connection_read_performance_counter_completion_enc;
2302 this->magma_virt_connection_create_image = &magma_virt_connection_create_image_enc;
2303 this->magma_virt_connection_get_image_info = &magma_virt_connection_get_image_info_enc;
2304 }
2305
2306