1 /*
2 * Copyright 2009 VMware, Inc.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
22 * USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /*
26 * This file holds the function implementation for one of the rbug extensions.
27 * Prototypes and declerations of functions and structs is in the same folder
28 * in the header file matching this file's name.
29 *
30 * The functions starting rbug_send_* encodes a call to the write format and
31 * sends that to the supplied connection, while functions starting with
32 * rbug_demarshal_* demarshal data in the wire protocol.
33 *
34 * Functions ending with _reply are replies to requests.
35 */
36
37 #include "rbug_internal.h"
38 #include "rbug_texture.h"
39
rbug_send_texture_list(struct rbug_connection * __con,uint32_t * __serial)40 int rbug_send_texture_list(struct rbug_connection *__con,
41 uint32_t *__serial)
42 {
43 uint32_t __len = 0;
44 uint32_t __pos = 0;
45 uint8_t *__data = NULL;
46 int __ret = 0;
47
48 LEN(8); /* header */
49
50 /* align */
51 PAD(__len, 8);
52
53 __data = (uint8_t*)MALLOC(__len);
54 if (!__data)
55 return -ENOMEM;
56
57 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST));
58 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
59
60 /* final pad */
61 PAD(__pos, 8);
62
63 if (__pos != __len) {
64 __ret = -EINVAL;
65 } else {
66 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST, __len);
67 rbug_connection_write(__con, __data, __len);
68 __ret = rbug_connection_send_finish(__con, __serial);
69 }
70
71 FREE(__data);
72 return __ret;
73 }
74
rbug_send_texture_info(struct rbug_connection * __con,rbug_texture_t texture,uint32_t * __serial)75 int rbug_send_texture_info(struct rbug_connection *__con,
76 rbug_texture_t texture,
77 uint32_t *__serial)
78 {
79 uint32_t __len = 0;
80 uint32_t __pos = 0;
81 uint8_t *__data = NULL;
82 int __ret = 0;
83
84 LEN(8); /* header */
85 LEN(8); /* texture */
86
87 /* align */
88 PAD(__len, 8);
89
90 __data = (uint8_t*)MALLOC(__len);
91 if (!__data)
92 return -ENOMEM;
93
94 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO));
95 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
96 WRITE(8, rbug_texture_t, texture); /* texture */
97
98 /* final pad */
99 PAD(__pos, 8);
100
101 if (__pos != __len) {
102 __ret = -EINVAL;
103 } else {
104 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO, __len);
105 rbug_connection_write(__con, __data, __len);
106 __ret = rbug_connection_send_finish(__con, __serial);
107 }
108
109 FREE(__data);
110 return __ret;
111 }
112
rbug_send_texture_write(struct rbug_connection * __con,rbug_texture_t texture,uint32_t face,uint32_t level,uint32_t zslice,uint32_t x,uint32_t y,uint32_t w,uint32_t h,uint8_t * data,uint32_t data_len,uint32_t stride,uint32_t * __serial)113 int rbug_send_texture_write(struct rbug_connection *__con,
114 rbug_texture_t texture,
115 uint32_t face,
116 uint32_t level,
117 uint32_t zslice,
118 uint32_t x,
119 uint32_t y,
120 uint32_t w,
121 uint32_t h,
122 uint8_t *data,
123 uint32_t data_len,
124 uint32_t stride,
125 uint32_t *__serial)
126 {
127 uint32_t __len = 0;
128 uint32_t __pos = 0;
129 uint8_t *__data = NULL;
130 int __ret = 0;
131
132 LEN(8); /* header */
133 LEN(8); /* texture */
134 LEN(4); /* face */
135 LEN(4); /* level */
136 LEN(4); /* zslice */
137 LEN(4); /* x */
138 LEN(4); /* y */
139 LEN(4); /* w */
140 LEN(4); /* h */
141 LEN_ARRAY(1, data); /* data */
142 LEN(4); /* stride */
143
144 /* align */
145 PAD(__len, 8);
146
147 __data = (uint8_t*)MALLOC(__len);
148 if (!__data)
149 return -ENOMEM;
150
151 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_WRITE));
152 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
153 WRITE(8, rbug_texture_t, texture); /* texture */
154 WRITE(4, uint32_t, face); /* face */
155 WRITE(4, uint32_t, level); /* level */
156 WRITE(4, uint32_t, zslice); /* zslice */
157 WRITE(4, uint32_t, x); /* x */
158 WRITE(4, uint32_t, y); /* y */
159 WRITE(4, uint32_t, w); /* w */
160 WRITE(4, uint32_t, h); /* h */
161 WRITE_ARRAY(1, uint8_t, data); /* data */
162 WRITE(4, uint32_t, stride); /* stride */
163
164 /* final pad */
165 PAD(__pos, 8);
166
167 if (__pos != __len) {
168 __ret = -EINVAL;
169 } else {
170 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_WRITE, __len);
171 rbug_connection_write(__con, __data, __len);
172 __ret = rbug_connection_send_finish(__con, __serial);
173 }
174
175 FREE(__data);
176 return __ret;
177 }
178
rbug_send_texture_read(struct rbug_connection * __con,rbug_texture_t texture,uint32_t face,uint32_t level,uint32_t zslice,uint32_t x,uint32_t y,uint32_t w,uint32_t h,uint32_t * __serial)179 int rbug_send_texture_read(struct rbug_connection *__con,
180 rbug_texture_t texture,
181 uint32_t face,
182 uint32_t level,
183 uint32_t zslice,
184 uint32_t x,
185 uint32_t y,
186 uint32_t w,
187 uint32_t h,
188 uint32_t *__serial)
189 {
190 uint32_t __len = 0;
191 uint32_t __pos = 0;
192 uint8_t *__data = NULL;
193 int __ret = 0;
194
195 LEN(8); /* header */
196 LEN(8); /* texture */
197 LEN(4); /* face */
198 LEN(4); /* level */
199 LEN(4); /* zslice */
200 LEN(4); /* x */
201 LEN(4); /* y */
202 LEN(4); /* w */
203 LEN(4); /* h */
204
205 /* align */
206 PAD(__len, 8);
207
208 __data = (uint8_t*)MALLOC(__len);
209 if (!__data)
210 return -ENOMEM;
211
212 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ));
213 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
214 WRITE(8, rbug_texture_t, texture); /* texture */
215 WRITE(4, uint32_t, face); /* face */
216 WRITE(4, uint32_t, level); /* level */
217 WRITE(4, uint32_t, zslice); /* zslice */
218 WRITE(4, uint32_t, x); /* x */
219 WRITE(4, uint32_t, y); /* y */
220 WRITE(4, uint32_t, w); /* w */
221 WRITE(4, uint32_t, h); /* h */
222
223 /* final pad */
224 PAD(__pos, 8);
225
226 if (__pos != __len) {
227 __ret = -EINVAL;
228 } else {
229 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ, __len);
230 rbug_connection_write(__con, __data, __len);
231 __ret = rbug_connection_send_finish(__con, __serial);
232 }
233
234 FREE(__data);
235 return __ret;
236 }
237
rbug_send_texture_list_reply(struct rbug_connection * __con,uint32_t serial,rbug_texture_t * textures,uint32_t textures_len,uint32_t * __serial)238 int rbug_send_texture_list_reply(struct rbug_connection *__con,
239 uint32_t serial,
240 rbug_texture_t *textures,
241 uint32_t textures_len,
242 uint32_t *__serial)
243 {
244 uint32_t __len = 0;
245 uint32_t __pos = 0;
246 uint8_t *__data = NULL;
247 int __ret = 0;
248
249 LEN(8); /* header */
250 LEN(4); /* serial */
251 LEN_ARRAY(8, textures); /* textures */
252
253 /* align */
254 PAD(__len, 8);
255
256 __data = (uint8_t*)MALLOC(__len);
257 if (!__data)
258 return -ENOMEM;
259
260 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST_REPLY));
261 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
262 WRITE(4, uint32_t, serial); /* serial */
263 WRITE_ARRAY(8, rbug_texture_t, textures); /* textures */
264
265 /* final pad */
266 PAD(__pos, 8);
267
268 if (__pos != __len) {
269 __ret = -EINVAL;
270 } else {
271 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST_REPLY, __len);
272 rbug_connection_write(__con, __data, __len);
273 __ret = rbug_connection_send_finish(__con, __serial);
274 }
275
276 FREE(__data);
277 return __ret;
278 }
279
rbug_send_texture_info_reply(struct rbug_connection * __con,uint32_t serial,uint32_t target,uint32_t format,uint32_t * width,uint32_t width_len,uint32_t * height,uint32_t height_len,uint32_t * depth,uint32_t depth_len,uint32_t blockw,uint32_t blockh,uint32_t blocksize,uint32_t last_level,uint32_t nr_samples,uint32_t tex_usage,uint32_t * __serial)280 int rbug_send_texture_info_reply(struct rbug_connection *__con,
281 uint32_t serial,
282 uint32_t target,
283 uint32_t format,
284 uint32_t *width,
285 uint32_t width_len,
286 uint32_t *height,
287 uint32_t height_len,
288 uint32_t *depth,
289 uint32_t depth_len,
290 uint32_t blockw,
291 uint32_t blockh,
292 uint32_t blocksize,
293 uint32_t last_level,
294 uint32_t nr_samples,
295 uint32_t tex_usage,
296 uint32_t *__serial)
297 {
298 uint32_t __len = 0;
299 uint32_t __pos = 0;
300 uint8_t *__data = NULL;
301 int __ret = 0;
302
303 LEN(8); /* header */
304 LEN(4); /* serial */
305 LEN(4); /* target */
306 LEN(4); /* format */
307 LEN_ARRAY(4, width); /* width */
308 LEN_ARRAY(4, height); /* height */
309 LEN_ARRAY(4, depth); /* depth */
310 LEN(4); /* blockw */
311 LEN(4); /* blockh */
312 LEN(4); /* blocksize */
313 LEN(4); /* last_level */
314 LEN(4); /* nr_samples */
315 LEN(4); /* tex_usage */
316
317 /* align */
318 PAD(__len, 8);
319
320 __data = (uint8_t*)MALLOC(__len);
321 if (!__data)
322 return -ENOMEM;
323
324 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO_REPLY));
325 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
326 WRITE(4, uint32_t, serial); /* serial */
327 WRITE(4, uint32_t, target); /* target */
328 WRITE(4, uint32_t, format); /* format */
329 WRITE_ARRAY(4, uint32_t, width); /* width */
330 WRITE_ARRAY(4, uint32_t, height); /* height */
331 WRITE_ARRAY(4, uint32_t, depth); /* depth */
332 WRITE(4, uint32_t, blockw); /* blockw */
333 WRITE(4, uint32_t, blockh); /* blockh */
334 WRITE(4, uint32_t, blocksize); /* blocksize */
335 WRITE(4, uint32_t, last_level); /* last_level */
336 WRITE(4, uint32_t, nr_samples); /* nr_samples */
337 WRITE(4, uint32_t, tex_usage); /* tex_usage */
338
339 /* final pad */
340 PAD(__pos, 8);
341
342 if (__pos != __len) {
343 __ret = -EINVAL;
344 } else {
345 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO_REPLY, __len);
346 rbug_connection_write(__con, __data, __len);
347 __ret = rbug_connection_send_finish(__con, __serial);
348 }
349
350 FREE(__data);
351 return __ret;
352 }
353
rbug_send_texture_read_reply(struct rbug_connection * __con,uint32_t serial,uint32_t format,uint32_t blockw,uint32_t blockh,uint32_t blocksize,uint8_t * data,uint32_t data_len,uint32_t stride,uint32_t * __serial)354 int rbug_send_texture_read_reply(struct rbug_connection *__con,
355 uint32_t serial,
356 uint32_t format,
357 uint32_t blockw,
358 uint32_t blockh,
359 uint32_t blocksize,
360 uint8_t *data,
361 uint32_t data_len,
362 uint32_t stride,
363 uint32_t *__serial)
364 {
365 uint32_t __len = 0;
366 uint32_t __pos = 0;
367 uint8_t *__data = NULL;
368 int __ret = 0;
369
370 LEN(8); /* header */
371 LEN(4); /* serial */
372 LEN(4); /* format */
373 LEN(4); /* blockw */
374 LEN(4); /* blockh */
375 LEN(4); /* blocksize */
376 LEN_ARRAY(1, data); /* data */
377 LEN(4); /* stride */
378
379 /* align */
380 PAD(__len, 8);
381
382 __data = (uint8_t*)MALLOC(__len);
383 if (!__data)
384 return -ENOMEM;
385
386 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ_REPLY));
387 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
388 WRITE(4, uint32_t, serial); /* serial */
389 WRITE(4, uint32_t, format); /* format */
390 WRITE(4, uint32_t, blockw); /* blockw */
391 WRITE(4, uint32_t, blockh); /* blockh */
392 WRITE(4, uint32_t, blocksize); /* blocksize */
393 WRITE_ARRAY(1, uint8_t, data); /* data */
394 WRITE(4, uint32_t, stride); /* stride */
395
396 /* final pad */
397 PAD(__pos, 8);
398
399 if (__pos != __len) {
400 __ret = -EINVAL;
401 } else {
402 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ_REPLY, __len);
403 rbug_connection_write(__con, __data, __len);
404 __ret = rbug_connection_send_finish(__con, __serial);
405 }
406
407 FREE(__data);
408 return __ret;
409 }
410
rbug_demarshal_texture_list(struct rbug_proto_header * header)411 struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header)
412 {
413 struct rbug_proto_texture_list *ret;
414
415 if (!header)
416 return NULL;
417 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST)
418 return NULL;
419
420 ret = MALLOC(sizeof(*ret));
421 if (!ret)
422 return NULL;
423
424 ret->header.__message = header;
425 ret->header.opcode = header->opcode;
426
427 return ret;
428 }
429
rbug_demarshal_texture_info(struct rbug_proto_header * header)430 struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header)
431 {
432 uint32_t len = 0;
433 uint32_t pos = 0;
434 uint8_t *data = NULL;
435 struct rbug_proto_texture_info *ret;
436
437 if (!header)
438 return NULL;
439 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO)
440 return NULL;
441
442 pos = 0;
443 len = header->length * 4;
444 data = (uint8_t*)&header[1];
445 ret = MALLOC(sizeof(*ret));
446 if (!ret)
447 return NULL;
448
449 ret->header.__message = header;
450 ret->header.opcode = header->opcode;
451
452 READ(8, rbug_texture_t, texture); /* texture */
453
454 return ret;
455 }
456
rbug_demarshal_texture_write(struct rbug_proto_header * header)457 struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header)
458 {
459 uint32_t len = 0;
460 uint32_t pos = 0;
461 uint8_t *data = NULL;
462 struct rbug_proto_texture_write *ret;
463
464 if (!header)
465 return NULL;
466 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_WRITE)
467 return NULL;
468
469 pos = 0;
470 len = header->length * 4;
471 data = (uint8_t*)&header[1];
472 ret = MALLOC(sizeof(*ret));
473 if (!ret)
474 return NULL;
475
476 ret->header.__message = header;
477 ret->header.opcode = header->opcode;
478
479 READ(8, rbug_texture_t, texture); /* texture */
480 READ(4, uint32_t, face); /* face */
481 READ(4, uint32_t, level); /* level */
482 READ(4, uint32_t, zslice); /* zslice */
483 READ(4, uint32_t, x); /* x */
484 READ(4, uint32_t, y); /* y */
485 READ(4, uint32_t, w); /* w */
486 READ(4, uint32_t, h); /* h */
487 READ_ARRAY(1, uint8_t, data); /* data */
488 READ(4, uint32_t, stride); /* stride */
489
490 return ret;
491 }
492
rbug_demarshal_texture_read(struct rbug_proto_header * header)493 struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header)
494 {
495 uint32_t len = 0;
496 uint32_t pos = 0;
497 uint8_t *data = NULL;
498 struct rbug_proto_texture_read *ret;
499
500 if (!header)
501 return NULL;
502 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ)
503 return NULL;
504
505 pos = 0;
506 len = header->length * 4;
507 data = (uint8_t*)&header[1];
508 ret = MALLOC(sizeof(*ret));
509 if (!ret)
510 return NULL;
511
512 ret->header.__message = header;
513 ret->header.opcode = header->opcode;
514
515 READ(8, rbug_texture_t, texture); /* texture */
516 READ(4, uint32_t, face); /* face */
517 READ(4, uint32_t, level); /* level */
518 READ(4, uint32_t, zslice); /* zslice */
519 READ(4, uint32_t, x); /* x */
520 READ(4, uint32_t, y); /* y */
521 READ(4, uint32_t, w); /* w */
522 READ(4, uint32_t, h); /* h */
523
524 return ret;
525 }
526
rbug_demarshal_texture_list_reply(struct rbug_proto_header * header)527 struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header)
528 {
529 uint32_t len = 0;
530 uint32_t pos = 0;
531 uint8_t *data = NULL;
532 struct rbug_proto_texture_list_reply *ret;
533
534 if (!header)
535 return NULL;
536 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST_REPLY)
537 return NULL;
538
539 pos = 0;
540 len = header->length * 4;
541 data = (uint8_t*)&header[1];
542 ret = MALLOC(sizeof(*ret));
543 if (!ret)
544 return NULL;
545
546 ret->header.__message = header;
547 ret->header.opcode = header->opcode;
548
549 READ(4, uint32_t, serial); /* serial */
550 READ_ARRAY(8, rbug_texture_t, textures); /* textures */
551
552 return ret;
553 }
554
rbug_demarshal_texture_info_reply(struct rbug_proto_header * header)555 struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header)
556 {
557 uint32_t len = 0;
558 uint32_t pos = 0;
559 uint8_t *data = NULL;
560 struct rbug_proto_texture_info_reply *ret;
561
562 if (!header)
563 return NULL;
564 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO_REPLY)
565 return NULL;
566
567 pos = 0;
568 len = header->length * 4;
569 data = (uint8_t*)&header[1];
570 ret = MALLOC(sizeof(*ret));
571 if (!ret)
572 return NULL;
573
574 ret->header.__message = header;
575 ret->header.opcode = header->opcode;
576
577 READ(4, uint32_t, serial); /* serial */
578 READ(4, uint32_t, target); /* target */
579 READ(4, uint32_t, format); /* format */
580 READ_ARRAY(4, uint32_t, width); /* width */
581 READ_ARRAY(4, uint32_t, height); /* height */
582 READ_ARRAY(4, uint32_t, depth); /* depth */
583 READ(4, uint32_t, blockw); /* blockw */
584 READ(4, uint32_t, blockh); /* blockh */
585 READ(4, uint32_t, blocksize); /* blocksize */
586 READ(4, uint32_t, last_level); /* last_level */
587 READ(4, uint32_t, nr_samples); /* nr_samples */
588 READ(4, uint32_t, tex_usage); /* tex_usage */
589
590 return ret;
591 }
592
rbug_demarshal_texture_read_reply(struct rbug_proto_header * header)593 struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header)
594 {
595 uint32_t len = 0;
596 uint32_t pos = 0;
597 uint8_t *data = NULL;
598 struct rbug_proto_texture_read_reply *ret;
599
600 if (!header)
601 return NULL;
602 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ_REPLY)
603 return NULL;
604
605 pos = 0;
606 len = header->length * 4;
607 data = (uint8_t*)&header[1];
608 ret = MALLOC(sizeof(*ret));
609 if (!ret)
610 return NULL;
611
612 ret->header.__message = header;
613 ret->header.opcode = header->opcode;
614
615 READ(4, uint32_t, serial); /* serial */
616 READ(4, uint32_t, format); /* format */
617 READ(4, uint32_t, blockw); /* blockw */
618 READ(4, uint32_t, blockh); /* blockh */
619 READ(4, uint32_t, blocksize); /* blocksize */
620 READ_ARRAY(1, uint8_t, data); /* data */
621 READ(4, uint32_t, stride); /* stride */
622
623 return ret;
624 }
625