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_shader.h"
39
rbug_send_shader_list(struct rbug_connection * __con,rbug_context_t context,uint32_t * __serial)40 int rbug_send_shader_list(struct rbug_connection *__con,
41 rbug_context_t context,
42 uint32_t *__serial)
43 {
44 uint32_t __len = 0;
45 uint32_t __pos = 0;
46 uint8_t *__data = NULL;
47 int __ret = 0;
48
49 LEN(8); /* header */
50 LEN(8); /* context */
51
52 /* align */
53 PAD(__len, 8);
54
55 __data = (uint8_t*)MALLOC(__len);
56 if (!__data)
57 return -ENOMEM;
58
59 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST));
60 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
61 WRITE(8, rbug_context_t, context); /* context */
62
63 /* final pad */
64 PAD(__pos, 8);
65
66 if (__pos != __len) {
67 __ret = -EINVAL;
68 } else {
69 rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST, __len);
70 rbug_connection_write(__con, __data, __len);
71 __ret = rbug_connection_send_finish(__con, __serial);
72 }
73
74 FREE(__data);
75 return __ret;
76 }
77
rbug_send_shader_info(struct rbug_connection * __con,rbug_context_t context,rbug_shader_t shader,uint32_t * __serial)78 int rbug_send_shader_info(struct rbug_connection *__con,
79 rbug_context_t context,
80 rbug_shader_t shader,
81 uint32_t *__serial)
82 {
83 uint32_t __len = 0;
84 uint32_t __pos = 0;
85 uint8_t *__data = NULL;
86 int __ret = 0;
87
88 LEN(8); /* header */
89 LEN(8); /* context */
90 LEN(8); /* shader */
91
92 /* align */
93 PAD(__len, 8);
94
95 __data = (uint8_t*)MALLOC(__len);
96 if (!__data)
97 return -ENOMEM;
98
99 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO));
100 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
101 WRITE(8, rbug_context_t, context); /* context */
102 WRITE(8, rbug_shader_t, shader); /* shader */
103
104 /* final pad */
105 PAD(__pos, 8);
106
107 if (__pos != __len) {
108 __ret = -EINVAL;
109 } else {
110 rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO, __len);
111 rbug_connection_write(__con, __data, __len);
112 __ret = rbug_connection_send_finish(__con, __serial);
113 }
114
115 FREE(__data);
116 return __ret;
117 }
118
rbug_send_shader_disable(struct rbug_connection * __con,rbug_context_t context,rbug_shader_t shader,uint8_t disable,uint32_t * __serial)119 int rbug_send_shader_disable(struct rbug_connection *__con,
120 rbug_context_t context,
121 rbug_shader_t shader,
122 uint8_t disable,
123 uint32_t *__serial)
124 {
125 uint32_t __len = 0;
126 uint32_t __pos = 0;
127 uint8_t *__data = NULL;
128 int __ret = 0;
129
130 LEN(8); /* header */
131 LEN(8); /* context */
132 LEN(8); /* shader */
133 LEN(1); /* disable */
134
135 /* align */
136 PAD(__len, 8);
137
138 __data = (uint8_t*)MALLOC(__len);
139 if (!__data)
140 return -ENOMEM;
141
142 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_DISABLE));
143 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
144 WRITE(8, rbug_context_t, context); /* context */
145 WRITE(8, rbug_shader_t, shader); /* shader */
146 WRITE(1, uint8_t, disable); /* disable */
147
148 /* final pad */
149 PAD(__pos, 8);
150
151 if (__pos != __len) {
152 __ret = -EINVAL;
153 } else {
154 rbug_connection_send_start(__con, RBUG_OP_SHADER_DISABLE, __len);
155 rbug_connection_write(__con, __data, __len);
156 __ret = rbug_connection_send_finish(__con, __serial);
157 }
158
159 FREE(__data);
160 return __ret;
161 }
162
rbug_send_shader_replace(struct rbug_connection * __con,rbug_context_t context,rbug_shader_t shader,uint32_t * tokens,uint32_t tokens_len,uint32_t * __serial)163 int rbug_send_shader_replace(struct rbug_connection *__con,
164 rbug_context_t context,
165 rbug_shader_t shader,
166 uint32_t *tokens,
167 uint32_t tokens_len,
168 uint32_t *__serial)
169 {
170 uint32_t __len = 0;
171 uint32_t __pos = 0;
172 uint8_t *__data = NULL;
173 int __ret = 0;
174
175 LEN(8); /* header */
176 LEN(8); /* context */
177 LEN(8); /* shader */
178 LEN_ARRAY(4, tokens); /* tokens */
179
180 /* align */
181 PAD(__len, 8);
182
183 __data = (uint8_t*)MALLOC(__len);
184 if (!__data)
185 return -ENOMEM;
186
187 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_REPLACE));
188 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
189 WRITE(8, rbug_context_t, context); /* context */
190 WRITE(8, rbug_shader_t, shader); /* shader */
191 WRITE_ARRAY(4, uint32_t, tokens); /* tokens */
192
193 /* final pad */
194 PAD(__pos, 8);
195
196 if (__pos != __len) {
197 __ret = -EINVAL;
198 } else {
199 rbug_connection_send_start(__con, RBUG_OP_SHADER_REPLACE, __len);
200 rbug_connection_write(__con, __data, __len);
201 __ret = rbug_connection_send_finish(__con, __serial);
202 }
203
204 FREE(__data);
205 return __ret;
206 }
207
rbug_send_shader_list_reply(struct rbug_connection * __con,uint32_t serial,rbug_shader_t * shaders,uint32_t shaders_len,uint32_t * __serial)208 int rbug_send_shader_list_reply(struct rbug_connection *__con,
209 uint32_t serial,
210 rbug_shader_t *shaders,
211 uint32_t shaders_len,
212 uint32_t *__serial)
213 {
214 uint32_t __len = 0;
215 uint32_t __pos = 0;
216 uint8_t *__data = NULL;
217 int __ret = 0;
218
219 LEN(8); /* header */
220 LEN(4); /* serial */
221 LEN_ARRAY(8, shaders); /* shaders */
222
223 /* align */
224 PAD(__len, 8);
225
226 __data = (uint8_t*)MALLOC(__len);
227 if (!__data)
228 return -ENOMEM;
229
230 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST_REPLY));
231 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
232 WRITE(4, uint32_t, serial); /* serial */
233 WRITE_ARRAY(8, rbug_shader_t, shaders); /* shaders */
234
235 /* final pad */
236 PAD(__pos, 8);
237
238 if (__pos != __len) {
239 __ret = -EINVAL;
240 } else {
241 rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST_REPLY, __len);
242 rbug_connection_write(__con, __data, __len);
243 __ret = rbug_connection_send_finish(__con, __serial);
244 }
245
246 FREE(__data);
247 return __ret;
248 }
249
rbug_send_shader_info_reply(struct rbug_connection * __con,uint32_t serial,uint32_t * original,uint32_t original_len,uint32_t * replaced,uint32_t replaced_len,uint8_t disabled,uint32_t * __serial)250 int rbug_send_shader_info_reply(struct rbug_connection *__con,
251 uint32_t serial,
252 uint32_t *original,
253 uint32_t original_len,
254 uint32_t *replaced,
255 uint32_t replaced_len,
256 uint8_t disabled,
257 uint32_t *__serial)
258 {
259 uint32_t __len = 0;
260 uint32_t __pos = 0;
261 uint8_t *__data = NULL;
262 int __ret = 0;
263
264 LEN(8); /* header */
265 LEN(4); /* serial */
266 LEN_ARRAY(4, original); /* original */
267 LEN_ARRAY(4, replaced); /* replaced */
268 LEN(1); /* disabled */
269
270 /* align */
271 PAD(__len, 8);
272
273 __data = (uint8_t*)MALLOC(__len);
274 if (!__data)
275 return -ENOMEM;
276
277 WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO_REPLY));
278 WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
279 WRITE(4, uint32_t, serial); /* serial */
280 WRITE_ARRAY(4, uint32_t, original); /* original */
281 WRITE_ARRAY(4, uint32_t, replaced); /* replaced */
282 WRITE(1, uint8_t, disabled); /* disabled */
283
284 /* final pad */
285 PAD(__pos, 8);
286
287 if (__pos != __len) {
288 __ret = -EINVAL;
289 } else {
290 rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO_REPLY, __len);
291 rbug_connection_write(__con, __data, __len);
292 __ret = rbug_connection_send_finish(__con, __serial);
293 }
294
295 FREE(__data);
296 return __ret;
297 }
298
rbug_demarshal_shader_list(struct rbug_proto_header * header)299 struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header)
300 {
301 uint32_t len = 0;
302 uint32_t pos = 0;
303 uint8_t *data = NULL;
304 struct rbug_proto_shader_list *ret;
305
306 if (!header)
307 return NULL;
308 if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST)
309 return NULL;
310
311 pos = 0;
312 len = header->length * 4;
313 data = (uint8_t*)&header[1];
314 ret = MALLOC(sizeof(*ret));
315 if (!ret)
316 return NULL;
317
318 ret->header.__message = header;
319 ret->header.opcode = header->opcode;
320
321 READ(8, rbug_context_t, context); /* context */
322
323 return ret;
324 }
325
rbug_demarshal_shader_info(struct rbug_proto_header * header)326 struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header)
327 {
328 uint32_t len = 0;
329 uint32_t pos = 0;
330 uint8_t *data = NULL;
331 struct rbug_proto_shader_info *ret;
332
333 if (!header)
334 return NULL;
335 if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO)
336 return NULL;
337
338 pos = 0;
339 len = header->length * 4;
340 data = (uint8_t*)&header[1];
341 ret = MALLOC(sizeof(*ret));
342 if (!ret)
343 return NULL;
344
345 ret->header.__message = header;
346 ret->header.opcode = header->opcode;
347
348 READ(8, rbug_context_t, context); /* context */
349 READ(8, rbug_shader_t, shader); /* shader */
350
351 return ret;
352 }
353
rbug_demarshal_shader_disable(struct rbug_proto_header * header)354 struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header)
355 {
356 uint32_t len = 0;
357 uint32_t pos = 0;
358 uint8_t *data = NULL;
359 struct rbug_proto_shader_disable *ret;
360
361 if (!header)
362 return NULL;
363 if (header->opcode != (int32_t)RBUG_OP_SHADER_DISABLE)
364 return NULL;
365
366 pos = 0;
367 len = header->length * 4;
368 data = (uint8_t*)&header[1];
369 ret = MALLOC(sizeof(*ret));
370 if (!ret)
371 return NULL;
372
373 ret->header.__message = header;
374 ret->header.opcode = header->opcode;
375
376 READ(8, rbug_context_t, context); /* context */
377 READ(8, rbug_shader_t, shader); /* shader */
378 READ(1, uint8_t, disable); /* disable */
379
380 return ret;
381 }
382
rbug_demarshal_shader_replace(struct rbug_proto_header * header)383 struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header)
384 {
385 uint32_t len = 0;
386 uint32_t pos = 0;
387 uint8_t *data = NULL;
388 struct rbug_proto_shader_replace *ret;
389
390 if (!header)
391 return NULL;
392 if (header->opcode != (int32_t)RBUG_OP_SHADER_REPLACE)
393 return NULL;
394
395 pos = 0;
396 len = header->length * 4;
397 data = (uint8_t*)&header[1];
398 ret = MALLOC(sizeof(*ret));
399 if (!ret)
400 return NULL;
401
402 ret->header.__message = header;
403 ret->header.opcode = header->opcode;
404
405 READ(8, rbug_context_t, context); /* context */
406 READ(8, rbug_shader_t, shader); /* shader */
407 READ_ARRAY(4, uint32_t, tokens); /* tokens */
408
409 return ret;
410 }
411
rbug_demarshal_shader_list_reply(struct rbug_proto_header * header)412 struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header)
413 {
414 uint32_t len = 0;
415 uint32_t pos = 0;
416 uint8_t *data = NULL;
417 struct rbug_proto_shader_list_reply *ret;
418
419 if (!header)
420 return NULL;
421 if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST_REPLY)
422 return NULL;
423
424 pos = 0;
425 len = header->length * 4;
426 data = (uint8_t*)&header[1];
427 ret = MALLOC(sizeof(*ret));
428 if (!ret)
429 return NULL;
430
431 ret->header.__message = header;
432 ret->header.opcode = header->opcode;
433
434 READ(4, uint32_t, serial); /* serial */
435 READ_ARRAY(8, rbug_shader_t, shaders); /* shaders */
436
437 return ret;
438 }
439
rbug_demarshal_shader_info_reply(struct rbug_proto_header * header)440 struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header)
441 {
442 uint32_t len = 0;
443 uint32_t pos = 0;
444 uint8_t *data = NULL;
445 struct rbug_proto_shader_info_reply *ret;
446
447 if (!header)
448 return NULL;
449 if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO_REPLY)
450 return NULL;
451
452 pos = 0;
453 len = header->length * 4;
454 data = (uint8_t*)&header[1];
455 ret = MALLOC(sizeof(*ret));
456 if (!ret)
457 return NULL;
458
459 ret->header.__message = header;
460 ret->header.opcode = header->opcode;
461
462 READ(4, uint32_t, serial); /* serial */
463 READ_ARRAY(4, uint32_t, original); /* original */
464 READ_ARRAY(4, uint32_t, replaced); /* replaced */
465 READ(1, uint8_t, disabled); /* disabled */
466
467 return ret;
468 }
469