# Gallium directories and
GALLIUM_DIRS = auxiliary drivers state_trackers
-GALLIUM_AUXILIARY_DIRS = draw translate cso_cache pipebuffer tgsi sct rtasm util indices
+GALLIUM_AUXILIARY_DIRS = rbug draw translate cso_cache pipebuffer tgsi sct rtasm util indices
GALLIUM_AUXILIARIES = $(foreach DIR,$(GALLIUM_AUXILIARY_DIRS),$(TOP)/src/gallium/auxiliary/$(DIR)/lib$(DIR).a)
GALLIUM_DRIVERS_DIRS = softpipe i915simple failover trace
GALLIUM_DRIVERS = $(foreach DIR,$(GALLIUM_DRIVERS_DIRS),$(TOP)/src/gallium/drivers/$(DIR)/lib$(DIR).a)
GALLIUM_DIRS="auxiliary drivers state_trackers"
GALLIUM_WINSYS_DIRS=""
GALLIUM_WINSYS_DRM_DIRS=""
-GALLIUM_AUXILIARY_DIRS="draw translate cso_cache pipebuffer tgsi sct rtasm util indices"
+GALLIUM_AUXILIARY_DIRS="rbug draw translate cso_cache pipebuffer tgsi sct rtasm util indices"
GALLIUM_DRIVERS_DIRS="softpipe failover trace"
GALLIUM_STATE_TRACKERS_DIRS=""
'auxiliary/draw/SConscript',
'auxiliary/pipebuffer/SConscript',
'auxiliary/indices/SConscript',
+ 'auxiliary/rbug/SConscript',
])
for driver in env['drivers']:
--- /dev/null
+TOP = ../../../..
+include $(TOP)/configs/current
+
+LIBNAME = rbug
+
+C_SOURCES = \
+ rbug_connection.c \
+ rbug_core.c \
+ rbug_texture.c \
+ rbug_context.c \
+ rbug_shader.c \
+ rbug_demarshal.c
+
+include ../../Makefile.template
--- /dev/null
+ GALLIUM REMOTE DEBUGGING COMMON CODE
+
+= About =
+
+This directory contains the common code for the Gallium 3D remote debugging
+driver and clients. The code is two parts the connection managment code and
+the (de)marsheller.
+
+The code currently uses tcp and ip4v for connections.
+
+Information about driver integration can be found in:
+
+src/gallium/drivers/trace/README
+
+for information about applications look in:
+
+progs/rbug/README
+
+
+--
+Jakob Bornecrantz <jakob@vmware.com>
--- /dev/null
+Import('*')
+
+rbug = env.ConvenienceLibrary(
+ target = 'rbug',
+ source = [
+ 'rbug_core.c',
+ 'rbug_shader.c',
+ 'rbug_context.c',
+ 'rbug_texture.c',
+ 'rbug_demarshal.c',
+ 'rbug_connection.c',
+ ])
+
+auxiliaries.insert(0, rbug)
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Include all for users the remote debugger protocol code.
+ */
+
+#include "rbug/rbug_core.h"
+#include "rbug/rbug_shader.h"
+#include "rbug/rbug_context.h"
+#include "rbug/rbug_texture.h"
+#include "rbug/rbug_connection.h"
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "rbug/rbug.h"
+#include "rbug/rbug_internal.h"
+
+#include "util/u_network.h"
+
+struct rbug_connection
+{
+ int socket;
+ uint32_t send_serial;
+ uint32_t recv_serial;
+ enum rbug_opcode opcode;
+};
+
+/**
+ * Create a rbug connection from a socket created with u_socket.
+ *
+ * Result:
+ * A new allocated connection using socket as communication path
+ */
+struct rbug_connection *
+rbug_from_socket(int socket)
+{
+ struct rbug_connection *c = CALLOC_STRUCT(rbug_connection);
+ c->socket = socket;
+ return c;
+}
+
+/**
+ * Free a connection, also closes socket.
+ */
+void
+rbug_disconnect(struct rbug_connection *c)
+{
+ u_socket_close(c->socket);
+ FREE(c);
+}
+
+/**
+ * Waits for a message to be fully received.
+ * Also returns the serial for the message, serial is not touched for replys.
+ *
+ * Result:
+ * demarshaled message on success, NULL on connection error
+ */
+struct rbug_header *
+rbug_get_message(struct rbug_connection *c, uint32_t *serial)
+{
+ struct rbug_proto_header header;
+ struct rbug_header *out;
+ struct rbug_proto_header *data;
+ size_t length = 0;
+ size_t read = 0;
+ int ret;
+
+
+ ret = u_socket_peek(c->socket, &header, sizeof(header));
+ if (ret <= 0) {
+ return NULL;
+ }
+
+ length = (size_t)header.length * 4;
+ data = MALLOC(length);
+ if (!data) {
+ return NULL;
+ }
+
+ do {
+ uint8_t *ptr = ((uint8_t*)data) + read;
+ ret = u_socket_recv(c->socket, ptr, length - read);
+
+ if (ret <= 0) {
+ FREE(data);
+ return NULL;
+ }
+
+ read += ret;
+ } while(read < length);
+
+ out = rbug_demarshal(data);
+ if (!out)
+ FREE(data);
+ else if (serial)
+ *serial = c->recv_serial++;
+ else
+ c->recv_serial++;
+
+ return out;
+}
+
+/**
+ * Frees a message and associated data.
+ */
+void
+rbug_free_header(struct rbug_header *header)
+{
+ if (!header)
+ return;
+
+ FREE(header->__message);
+ FREE(header);
+}
+
+/**
+ * Internal function used by rbug_send_* functions.
+ *
+ * Start sending a message.
+ */
+int
+rbug_connection_send_start(struct rbug_connection *c, enum rbug_opcode opcode, uint32_t length)
+{
+ c->opcode = opcode;
+ return 0;
+}
+
+/**
+ * Internal function used by rbug_send_* functions.
+ *
+ * Write data to the socket.
+ */
+int
+rbug_connection_write(struct rbug_connection *c, void *to, uint32_t size)
+{
+ int ret = u_socket_send(c->socket, to, size);
+ return ret;
+}
+
+/**
+ * Internal function used by rbug_send_* functions.
+ *
+ * Finish writeing data to the socket.
+ * Ups the send_serial and sets the serial argument if supplied.
+ */
+int rbug_connection_send_finish(struct rbug_connection *c, uint32_t *serial)
+{
+ if (c->opcode < 0)
+ return 0;
+ else if (serial)
+ *serial = c->send_serial++;
+ else
+ c->send_serial++;
+
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file contains the function defentions for connection see c file for
+ * more comments covering function use.
+ */
+
+#ifndef _RBUG_CONNECTION_H_
+#define _RBUG_CONNECTION_H_
+
+#include "rbug/rbug_proto.h"
+
+struct rbug_connection * rbug_from_socket(int socket);
+
+void rbug_disconnect(struct rbug_connection *c);
+
+struct rbug_header * rbug_get_message(struct rbug_connection *c, uint32_t *serial);
+
+void rbug_free_header(struct rbug_header *header);
+
+struct rbug_header * rbug_demarshal(struct rbug_proto_header *header);
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds the function implementation for one of the rbug extensions.
+ * Prototypes and declerations of functions and structs is in the same folder
+ * in the header file matching this file's name.
+ *
+ * The functions starting rbug_send_* encodes a call to the write format and
+ * sends that to the supplied connection, while functions starting with
+ * rbug_demarshal_* demarshal data in the wire protocol.
+ *
+ * Functions ending with _reply are replies to requests.
+ */
+
+#include "rbug_internal.h"
+#include "rbug/rbug_context.h"
+
+int rbug_send_context_list(struct rbug_connection *__con,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_context_info(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_context_block_draw(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_BLOCK_DRAW));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_BLOCK_DRAW, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_context_unblock_draw(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_UNBLOCK_DRAW));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_UNBLOCK_DRAW, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_context_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_context_t *contexts,
+ uint32_t contexts_len,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN_ARRAY(8, contexts); /* contexts */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_context_info_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_texture_t *cbufs,
+ uint32_t cbufs_len,
+ rbug_texture_t zdbuf,
+ uint8_t blocked,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN_ARRAY(8, cbufs); /* cbufs */
+ LEN(8); /* zdbuf */
+ LEN(1); /* blocked */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
+ WRITE(8, rbug_texture_t, zdbuf); /* zdbuf */
+ WRITE(1, uint8_t, blocked); /* blocked */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_list *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+
+ return ret;
+}
+
+struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_info *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+
+ return ret;
+}
+
+struct rbug_proto_context_block_draw * rbug_demarshal_context_block_draw(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_block_draw *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_BLOCK_DRAW)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+
+ return ret;
+}
+
+struct rbug_proto_context_unblock_draw * rbug_demarshal_context_unblock_draw(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_unblock_draw *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_UNBLOCK_DRAW)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+
+ return ret;
+}
+
+struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_list_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ_ARRAY(8, rbug_context_t, contexts); /* contexts */
+
+ return ret;
+}
+
+struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_context_info_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
+ READ(8, rbug_texture_t, zdbuf); /* zdbuf */
+ READ(1, uint8_t, blocked); /* blocked */
+
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds structs decelerations and function prototypes for one of
+ * the rbug extensions. Implementation of the functions is in the same folder
+ * in the c file matching this file's name.
+ *
+ * The structs what is returned from the demarshal functions. The functions
+ * starting rbug_send_* encodes a call to the write format and sends that to
+ * the supplied connection, while functions starting with rbug_demarshal_*
+ * demarshal data from the wire protocol.
+ *
+ * Structs and functions ending with _reply are replies to requests.
+ */
+
+#ifndef _RBUG_PROTO_CONTEXT_H_
+#define _RBUG_PROTO_CONTEXT_H_
+
+#include "rbug/rbug_proto.h"
+#include "rbug/rbug_texture.h"
+
+typedef uint64_t rbug_context_t;
+
+struct rbug_proto_context_list
+{
+ struct rbug_header header;
+};
+
+struct rbug_proto_context_info
+{
+ struct rbug_header header;
+ rbug_context_t context;
+};
+
+struct rbug_proto_context_block_draw
+{
+ struct rbug_header header;
+ rbug_context_t context;
+};
+
+struct rbug_proto_context_unblock_draw
+{
+ struct rbug_header header;
+ rbug_context_t context;
+};
+
+struct rbug_proto_context_list_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ rbug_context_t *contexts;
+ uint32_t contexts_len;
+};
+
+struct rbug_proto_context_info_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ rbug_texture_t *cbufs;
+ uint32_t cbufs_len;
+ rbug_texture_t zdbuf;
+ uint8_t blocked;
+};
+
+int rbug_send_context_list(struct rbug_connection *__con,
+ uint32_t *__serial);
+
+int rbug_send_context_info(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial);
+
+int rbug_send_context_block_draw(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial);
+
+int rbug_send_context_unblock_draw(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial);
+
+int rbug_send_context_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_context_t *contexts,
+ uint32_t contexts_len,
+ uint32_t *__serial);
+
+int rbug_send_context_info_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_texture_t *cbufs,
+ uint32_t cbufs_len,
+ rbug_texture_t zdbuf,
+ uint8_t blocked,
+ uint32_t *__serial);
+
+struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header);
+
+struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header);
+
+struct rbug_proto_context_block_draw * rbug_demarshal_context_block_draw(struct rbug_proto_header *header);
+
+struct rbug_proto_context_unblock_draw * rbug_demarshal_context_unblock_draw(struct rbug_proto_header *header);
+
+struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header);
+
+struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header);
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds the function implementation for one of the rbug extensions.
+ * Prototypes and declerations of functions and structs is in the same folder
+ * in the header file matching this file's name.
+ *
+ * The functions starting rbug_send_* encodes a call to the write format and
+ * sends that to the supplied connection, while functions starting with
+ * rbug_demarshal_* demarshal data in the wire protocol.
+ *
+ * Functions ending with _reply are replies to requests.
+ */
+
+#include "rbug_internal.h"
+#include "rbug/rbug_core.h"
+
+int rbug_send_noop(struct rbug_connection *__con,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_NOOP));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_NOOP, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_ping(struct rbug_connection *__con,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_PING));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_PING, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_error(struct rbug_connection *__con,
+ uint32_t error,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* error */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, error); /* error */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_ERROR, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_ping_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_PING_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_PING_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_error_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ uint32_t error,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN(4); /* error */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE(4, uint32_t, error); /* error */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_ERROR_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+struct rbug_proto_noop * rbug_demarshal_noop(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_noop *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_NOOP)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+
+ return ret;
+}
+
+struct rbug_proto_ping * rbug_demarshal_ping(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_ping *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_PING)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+
+ return ret;
+}
+
+struct rbug_proto_error * rbug_demarshal_error(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_error *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_ERROR)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, error); /* error */
+
+ return ret;
+}
+
+struct rbug_proto_ping_reply * rbug_demarshal_ping_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_ping_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_PING_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+
+ return ret;
+}
+
+struct rbug_proto_error_reply * rbug_demarshal_error_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_error_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_ERROR_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ(4, uint32_t, error); /* error */
+
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds structs decelerations and function prototypes for one of
+ * the rbug extensions. Implementation of the functions is in the same folder
+ * in the c file matching this file's name.
+ *
+ * The structs what is returned from the demarshal functions. The functions
+ * starting rbug_send_* encodes a call to the write format and sends that to
+ * the supplied connection, while functions starting with rbug_demarshal_*
+ * demarshal data from the wire protocol.
+ *
+ * Structs and functions ending with _reply are replies to requests.
+ */
+
+#ifndef _RBUG_PROTO_CORE_H_
+#define _RBUG_PROTO_CORE_H_
+
+#include "rbug/rbug_proto.h"
+
+struct rbug_proto_noop
+{
+ struct rbug_header header;
+};
+
+struct rbug_proto_ping
+{
+ struct rbug_header header;
+};
+
+struct rbug_proto_error
+{
+ struct rbug_header header;
+ uint32_t error;
+};
+
+struct rbug_proto_ping_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+};
+
+struct rbug_proto_error_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ uint32_t error;
+};
+
+int rbug_send_noop(struct rbug_connection *__con,
+ uint32_t *__serial);
+
+int rbug_send_ping(struct rbug_connection *__con,
+ uint32_t *__serial);
+
+int rbug_send_error(struct rbug_connection *__con,
+ uint32_t error,
+ uint32_t *__serial);
+
+int rbug_send_ping_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ uint32_t *__serial);
+
+int rbug_send_error_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ uint32_t error,
+ uint32_t *__serial);
+
+struct rbug_proto_noop * rbug_demarshal_noop(struct rbug_proto_header *header);
+
+struct rbug_proto_ping * rbug_demarshal_ping(struct rbug_proto_header *header);
+
+struct rbug_proto_error * rbug_demarshal_error(struct rbug_proto_header *header);
+
+struct rbug_proto_ping_reply * rbug_demarshal_ping_reply(struct rbug_proto_header *header);
+
+struct rbug_proto_error_reply * rbug_demarshal_error_reply(struct rbug_proto_header *header);
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "rbug.h"
+
+/**
+ * Small function that looks at the proto_header and selects the correct
+ * demarshal functions and return the result.
+ */
+struct rbug_header * rbug_demarshal(struct rbug_proto_header *header)
+{
+ switch(header->opcode) {
+ case RBUG_OP_NOOP:
+ return (struct rbug_header *)rbug_demarshal_noop(header);
+ case RBUG_OP_PING:
+ return (struct rbug_header *)rbug_demarshal_ping(header);
+ case RBUG_OP_ERROR:
+ return (struct rbug_header *)rbug_demarshal_error(header);
+ case RBUG_OP_PING_REPLY:
+ return (struct rbug_header *)rbug_demarshal_ping_reply(header);
+ case RBUG_OP_ERROR_REPLY:
+ return (struct rbug_header *)rbug_demarshal_error_reply(header);
+ case RBUG_OP_TEXTURE_LIST:
+ return (struct rbug_header *)rbug_demarshal_texture_list(header);
+ case RBUG_OP_TEXTURE_INFO:
+ return (struct rbug_header *)rbug_demarshal_texture_info(header);
+ case RBUG_OP_TEXTURE_WRITE:
+ return (struct rbug_header *)rbug_demarshal_texture_write(header);
+ case RBUG_OP_TEXTURE_READ:
+ return (struct rbug_header *)rbug_demarshal_texture_read(header);
+ case RBUG_OP_TEXTURE_LIST_REPLY:
+ return (struct rbug_header *)rbug_demarshal_texture_list_reply(header);
+ case RBUG_OP_TEXTURE_INFO_REPLY:
+ return (struct rbug_header *)rbug_demarshal_texture_info_reply(header);
+ case RBUG_OP_TEXTURE_READ_REPLY:
+ return (struct rbug_header *)rbug_demarshal_texture_read_reply(header);
+ case RBUG_OP_CONTEXT_LIST:
+ return (struct rbug_header *)rbug_demarshal_context_list(header);
+ case RBUG_OP_CONTEXT_INFO:
+ return (struct rbug_header *)rbug_demarshal_context_info(header);
+ case RBUG_OP_CONTEXT_BLOCK_DRAW:
+ return (struct rbug_header *)rbug_demarshal_context_block_draw(header);
+ case RBUG_OP_CONTEXT_UNBLOCK_DRAW:
+ return (struct rbug_header *)rbug_demarshal_context_unblock_draw(header);
+ case RBUG_OP_CONTEXT_LIST_REPLY:
+ return (struct rbug_header *)rbug_demarshal_context_list_reply(header);
+ case RBUG_OP_CONTEXT_INFO_REPLY:
+ return (struct rbug_header *)rbug_demarshal_context_info_reply(header);
+ case RBUG_OP_SHADER_LIST:
+ return (struct rbug_header *)rbug_demarshal_shader_list(header);
+ case RBUG_OP_SHADER_INFO:
+ return (struct rbug_header *)rbug_demarshal_shader_info(header);
+ case RBUG_OP_SHADER_DISABLE:
+ return (struct rbug_header *)rbug_demarshal_shader_disable(header);
+ case RBUG_OP_SHADER_REPLACE:
+ return (struct rbug_header *)rbug_demarshal_shader_replace(header);
+ case RBUG_OP_SHADER_LIST_REPLY:
+ return (struct rbug_header *)rbug_demarshal_shader_list_reply(header);
+ case RBUG_OP_SHADER_INFO_REPLY:
+ return (struct rbug_header *)rbug_demarshal_shader_info_reply(header);
+ default:
+ return NULL;
+ }
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file is internal to the rbug protocol code, and contains asorted
+ * features needed by the code.
+ */
+
+#ifndef _RBUG_INTERNAL_H_
+#define _RBUG_INTERNAL_H_
+
+#include "rbug/rbug_proto.h"
+
+#include "util/u_memory.h"
+#include "util/u_debug.h"
+#include <errno.h>
+
+int rbug_connection_send_start(struct rbug_connection *con, enum rbug_opcode opcode, uint32_t length);
+int rbug_connection_write(struct rbug_connection *con, void *data, uint32_t size);
+int rbug_connection_send_finish(struct rbug_connection *con, uint32_t *c);
+
+/**
+ * Only works with multiples of 2
+ */
+#define PAD(from, to) \
+do { \
+ from = (from + to - 1) & ~(to - 1); \
+} while(0)
+
+#define LEN(size) \
+do { \
+ PAD(__len, size); \
+ __len += size; \
+} while(0)
+
+#define LEN_ARRAY(size, name) \
+do { \
+ LEN(4); \
+ PAD(__len, size); \
+ __len += size * name##_len; \
+} while(0)
+
+#define WRITE(size, type, name) \
+do { \
+ PAD(__pos, size); \
+ *((type *)(&__data[__pos])) = name; \
+ __pos += size; \
+} while(0)
+
+#define WRITE_ARRAY(size, type, name) \
+do { \
+ WRITE(4, uint32_t, name##_len); \
+ PAD(__pos, size); \
+ memcpy(&__data[__pos], name, size * name##_len); \
+ __pos += size * name##_len; \
+} while(0)
+
+#define READ(size, type, name) \
+do { \
+ PAD(pos, size); \
+ pos += size; \
+ if (pos > len) \
+ break; \
+ ret->name = *((type *)(&data[pos - size])); \
+} while(0)
+
+#define READ_ARRAY(size, type, name) \
+do { \
+ READ(4, uint32_t, name##_len); \
+ if (pos > len) \
+ break; \
+ PAD(pos, size); \
+ pos += size * ret->name##_len; \
+ if (pos > len) \
+ break; \
+ ret->name = (type *)&data[pos - size * ret->name##_len]; \
+} while(0)
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds common definitions of the gallium remote debugging protocol.
+ */
+
+#ifndef _RBUG_PROTO_H_
+#define _RBUG_PROTO_H_
+
+#include "pipe/p_compiler.h"
+
+/**
+ * Uniqe indentifier for each command.
+ *
+ * Replys are designated by negative.
+ */
+enum rbug_opcode
+{
+ RBUG_OP_NOOP = 0,
+ RBUG_OP_PING = 1,
+ RBUG_OP_ERROR = 2,
+ RBUG_OP_PING_REPLY = -1,
+ RBUG_OP_ERROR_REPLY = -2,
+ RBUG_OP_TEXTURE_LIST = 256,
+ RBUG_OP_TEXTURE_INFO = 257,
+ RBUG_OP_TEXTURE_WRITE = 258,
+ RBUG_OP_TEXTURE_READ = 259,
+ RBUG_OP_TEXTURE_LIST_REPLY = -256,
+ RBUG_OP_TEXTURE_INFO_REPLY = -257,
+ RBUG_OP_TEXTURE_READ_REPLY = -259,
+ RBUG_OP_CONTEXT_LIST = 512,
+ RBUG_OP_CONTEXT_INFO = 513,
+ RBUG_OP_CONTEXT_BLOCK_DRAW = 514,
+ RBUG_OP_CONTEXT_UNBLOCK_DRAW = 515,
+ RBUG_OP_CONTEXT_LIST_REPLY = -512,
+ RBUG_OP_CONTEXT_INFO_REPLY = -513,
+ RBUG_OP_SHADER_LIST = 768,
+ RBUG_OP_SHADER_INFO = 769,
+ RBUG_OP_SHADER_DISABLE = 770,
+ RBUG_OP_SHADER_REPLACE = 771,
+ RBUG_OP_SHADER_LIST_REPLY = -768,
+ RBUG_OP_SHADER_INFO_REPLY = -769,
+};
+
+/**
+ * Header for demarshaled message.
+ */
+struct rbug_header
+{
+ enum rbug_opcode opcode;
+ void *__message;
+};
+
+/**
+ * Header for a message in wire format.
+ */
+struct rbug_proto_header
+{
+ int32_t opcode;
+ uint32_t length;
+};
+
+/**
+ * Forward declare connection here, as this file is included by all users.
+ */
+struct rbug_connection;
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds the function implementation for one of the rbug extensions.
+ * Prototypes and declerations of functions and structs is in the same folder
+ * in the header file matching this file's name.
+ *
+ * The functions starting rbug_send_* encodes a call to the write format and
+ * sends that to the supplied connection, while functions starting with
+ * rbug_demarshal_* demarshal data in the wire protocol.
+ *
+ * Functions ending with _reply are replies to requests.
+ */
+
+#include "rbug_internal.h"
+#include "rbug/rbug_shader.h"
+
+int rbug_send_shader_list(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_shader_info(struct rbug_connection *__con,
+ rbug_context_t context,
+ rbug_shader_t shader,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+ LEN(8); /* shader */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+ WRITE(8, rbug_shader_t, shader); /* shader */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_shader_disable(struct rbug_connection *__con,
+ rbug_context_t context,
+ rbug_shader_t shader,
+ uint8_t disable,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+ LEN(8); /* shader */
+ LEN(1); /* disable */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_DISABLE));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+ WRITE(8, rbug_shader_t, shader); /* shader */
+ WRITE(1, uint8_t, disable); /* disable */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_DISABLE, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* context */
+ LEN(8); /* shader */
+ LEN_ARRAY(4, tokens); /* tokens */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_REPLACE));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_context_t, context); /* context */
+ WRITE(8, rbug_shader_t, shader); /* shader */
+ WRITE_ARRAY(4, uint32_t, tokens); /* tokens */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_REPLACE, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_shader_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_shader_t *shaders,
+ uint32_t shaders_len,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN_ARRAY(8, shaders); /* shaders */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE_ARRAY(8, rbug_shader_t, shaders); /* shaders */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN_ARRAY(4, original); /* original */
+ LEN_ARRAY(4, replaced); /* replaced */
+ LEN(1); /* disabled */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE_ARRAY(4, uint32_t, original); /* original */
+ WRITE_ARRAY(4, uint32_t, replaced); /* replaced */
+ WRITE(1, uint8_t, disabled); /* disabled */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_list *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_LIST)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+
+ return ret;
+}
+
+struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_info *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_INFO)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+ READ(8, rbug_shader_t, shader); /* shader */
+
+ return ret;
+}
+
+struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_disable *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_DISABLE)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+ READ(8, rbug_shader_t, shader); /* shader */
+ READ(1, uint8_t, disable); /* disable */
+
+ return ret;
+}
+
+struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_replace *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_REPLACE)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_context_t, context); /* context */
+ READ(8, rbug_shader_t, shader); /* shader */
+ READ_ARRAY(4, uint32_t, tokens); /* tokens */
+
+ return ret;
+}
+
+struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_list_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_LIST_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ_ARRAY(8, rbug_shader_t, shaders); /* shaders */
+
+ return ret;
+}
+
+struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_shader_info_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_SHADER_INFO_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ_ARRAY(4, uint32_t, original); /* original */
+ READ_ARRAY(4, uint32_t, replaced); /* replaced */
+ READ(1, uint8_t, disabled); /* disabled */
+
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds structs decelerations and function prototypes for one of
+ * the rbug extensions. Implementation of the functions is in the same folder
+ * in the c file matching this file's name.
+ *
+ * The structs what is returned from the demarshal functions. The functions
+ * starting rbug_send_* encodes a call to the write format and sends that to
+ * the supplied connection, while functions starting with rbug_demarshal_*
+ * demarshal data from the wire protocol.
+ *
+ * Structs and functions ending with _reply are replies to requests.
+ */
+
+#ifndef _RBUG_PROTO_SHADER_H_
+#define _RBUG_PROTO_SHADER_H_
+
+#include "rbug/rbug_proto.h"
+#include "rbug/rbug_context.h"
+
+typedef uint64_t rbug_shader_t;
+
+struct rbug_proto_shader_list
+{
+ struct rbug_header header;
+ rbug_context_t context;
+};
+
+struct rbug_proto_shader_info
+{
+ struct rbug_header header;
+ rbug_context_t context;
+ rbug_shader_t shader;
+};
+
+struct rbug_proto_shader_disable
+{
+ struct rbug_header header;
+ rbug_context_t context;
+ rbug_shader_t shader;
+ uint8_t disable;
+};
+
+struct rbug_proto_shader_replace
+{
+ struct rbug_header header;
+ rbug_context_t context;
+ rbug_shader_t shader;
+ uint32_t *tokens;
+ uint32_t tokens_len;
+};
+
+struct rbug_proto_shader_list_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ rbug_shader_t *shaders;
+ uint32_t shaders_len;
+};
+
+struct rbug_proto_shader_info_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ uint32_t *original;
+ uint32_t original_len;
+ uint32_t *replaced;
+ uint32_t replaced_len;
+ uint8_t disabled;
+};
+
+int rbug_send_shader_list(struct rbug_connection *__con,
+ rbug_context_t context,
+ uint32_t *__serial);
+
+int rbug_send_shader_info(struct rbug_connection *__con,
+ rbug_context_t context,
+ rbug_shader_t shader,
+ uint32_t *__serial);
+
+int rbug_send_shader_disable(struct rbug_connection *__con,
+ rbug_context_t context,
+ rbug_shader_t shader,
+ uint8_t disable,
+ uint32_t *__serial);
+
+int 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);
+
+int rbug_send_shader_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_shader_t *shaders,
+ uint32_t shaders_len,
+ uint32_t *__serial);
+
+int 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);
+
+struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header);
+
+struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header);
+
+struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header);
+
+struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header);
+
+struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header);
+
+struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header);
+
+#endif
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds the function implementation for one of the rbug extensions.
+ * Prototypes and declerations of functions and structs is in the same folder
+ * in the header file matching this file's name.
+ *
+ * The functions starting rbug_send_* encodes a call to the write format and
+ * sends that to the supplied connection, while functions starting with
+ * rbug_demarshal_* demarshal data in the wire protocol.
+ *
+ * Functions ending with _reply are replies to requests.
+ */
+
+#include "rbug_internal.h"
+#include "rbug/rbug_texture.h"
+
+int rbug_send_texture_list(struct rbug_connection *__con,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_texture_info(struct rbug_connection *__con,
+ rbug_texture_t texture,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* texture */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_texture_t, texture); /* texture */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* texture */
+ LEN(4); /* face */
+ LEN(4); /* level */
+ LEN(4); /* zslice */
+ LEN(4); /* x */
+ LEN(4); /* y */
+ LEN(4); /* w */
+ LEN(4); /* h */
+ LEN_ARRAY(1, data); /* data */
+ LEN(4); /* stride */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_WRITE));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_texture_t, texture); /* texture */
+ WRITE(4, uint32_t, face); /* face */
+ WRITE(4, uint32_t, level); /* level */
+ WRITE(4, uint32_t, zslice); /* zslice */
+ WRITE(4, uint32_t, x); /* x */
+ WRITE(4, uint32_t, y); /* y */
+ WRITE(4, uint32_t, w); /* w */
+ WRITE(4, uint32_t, h); /* h */
+ WRITE_ARRAY(1, uint8_t, data); /* data */
+ WRITE(4, uint32_t, stride); /* stride */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_WRITE, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(8); /* texture */
+ LEN(4); /* face */
+ LEN(4); /* level */
+ LEN(4); /* zslice */
+ LEN(4); /* x */
+ LEN(4); /* y */
+ LEN(4); /* w */
+ LEN(4); /* h */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(8, rbug_texture_t, texture); /* texture */
+ WRITE(4, uint32_t, face); /* face */
+ WRITE(4, uint32_t, level); /* level */
+ WRITE(4, uint32_t, zslice); /* zslice */
+ WRITE(4, uint32_t, x); /* x */
+ WRITE(4, uint32_t, y); /* y */
+ WRITE(4, uint32_t, w); /* w */
+ WRITE(4, uint32_t, h); /* h */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int rbug_send_texture_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_texture_t *textures,
+ uint32_t textures_len,
+ uint32_t *__serial)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN_ARRAY(8, textures); /* textures */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE_ARRAY(8, rbug_texture_t, textures); /* textures */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN(4); /* target */
+ LEN(4); /* format */
+ LEN_ARRAY(4, width); /* width */
+ LEN_ARRAY(4, height); /* height */
+ LEN_ARRAY(4, depth); /* depth */
+ LEN(4); /* blockw */
+ LEN(4); /* blockh */
+ LEN(4); /* blocksize */
+ LEN(4); /* last_level */
+ LEN(4); /* nr_samples */
+ LEN(4); /* tex_usage */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE(4, uint32_t, target); /* target */
+ WRITE(4, uint32_t, format); /* format */
+ WRITE_ARRAY(4, uint32_t, width); /* width */
+ WRITE_ARRAY(4, uint32_t, height); /* height */
+ WRITE_ARRAY(4, uint32_t, depth); /* depth */
+ WRITE(4, uint32_t, blockw); /* blockw */
+ WRITE(4, uint32_t, blockh); /* blockh */
+ WRITE(4, uint32_t, blocksize); /* blocksize */
+ WRITE(4, uint32_t, last_level); /* last_level */
+ WRITE(4, uint32_t, nr_samples); /* nr_samples */
+ WRITE(4, uint32_t, tex_usage); /* tex_usage */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+int 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)
+{
+ uint32_t __len = 0;
+ uint32_t __pos = 0;
+ uint8_t *__data = NULL;
+ int __ret = 0;
+
+ LEN(8); /* header */
+ LEN(4); /* serial */
+ LEN(4); /* format */
+ LEN(4); /* blockw */
+ LEN(4); /* blockh */
+ LEN(4); /* blocksize */
+ LEN_ARRAY(1, data); /* data */
+ LEN(4); /* stride */
+
+ /* align */
+ PAD(__len, 8);
+
+ __data = (uint8_t*)MALLOC(__len);
+ if (!__data)
+ return -ENOMEM;
+
+ WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ_REPLY));
+ WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+ WRITE(4, uint32_t, serial); /* serial */
+ WRITE(4, uint32_t, format); /* format */
+ WRITE(4, uint32_t, blockw); /* blockw */
+ WRITE(4, uint32_t, blockh); /* blockh */
+ WRITE(4, uint32_t, blocksize); /* blocksize */
+ WRITE_ARRAY(1, uint8_t, data); /* data */
+ WRITE(4, uint32_t, stride); /* stride */
+
+ /* final pad */
+ PAD(__pos, 8);
+
+ if (__pos != __len) {
+ __ret = -EINVAL;
+ } else {
+ rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ_REPLY, __len);
+ rbug_connection_write(__con, __data, __len);
+ __ret = rbug_connection_send_finish(__con, __serial);
+ }
+
+ FREE(__data);
+ return __ret;
+}
+
+struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_list *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_LIST)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+
+ return ret;
+}
+
+struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_info *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_INFO)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_texture_t, texture); /* texture */
+
+ return ret;
+}
+
+struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_write *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_WRITE)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_texture_t, texture); /* texture */
+ READ(4, uint32_t, face); /* face */
+ READ(4, uint32_t, level); /* level */
+ READ(4, uint32_t, zslice); /* zslice */
+ READ(4, uint32_t, x); /* x */
+ READ(4, uint32_t, y); /* y */
+ READ(4, uint32_t, w); /* w */
+ READ(4, uint32_t, h); /* h */
+ READ_ARRAY(1, uint8_t, data); /* data */
+ READ(4, uint32_t, stride); /* stride */
+
+ return ret;
+}
+
+struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_read *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_READ)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(8, rbug_texture_t, texture); /* texture */
+ READ(4, uint32_t, face); /* face */
+ READ(4, uint32_t, level); /* level */
+ READ(4, uint32_t, zslice); /* zslice */
+ READ(4, uint32_t, x); /* x */
+ READ(4, uint32_t, y); /* y */
+ READ(4, uint32_t, w); /* w */
+ READ(4, uint32_t, h); /* h */
+
+ return ret;
+}
+
+struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_list_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_LIST_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ_ARRAY(8, rbug_texture_t, textures); /* textures */
+
+ return ret;
+}
+
+struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_info_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_INFO_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ(4, uint32_t, target); /* target */
+ READ(4, uint32_t, format); /* format */
+ READ_ARRAY(4, uint32_t, width); /* width */
+ READ_ARRAY(4, uint32_t, height); /* height */
+ READ_ARRAY(4, uint32_t, depth); /* depth */
+ READ(4, uint32_t, blockw); /* blockw */
+ READ(4, uint32_t, blockh); /* blockh */
+ READ(4, uint32_t, blocksize); /* blocksize */
+ READ(4, uint32_t, last_level); /* last_level */
+ READ(4, uint32_t, nr_samples); /* nr_samples */
+ READ(4, uint32_t, tex_usage); /* tex_usage */
+
+ return ret;
+}
+
+struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header)
+{
+ uint32_t len = 0;
+ uint32_t pos = 0;
+ uint8_t *data = NULL;
+ struct rbug_proto_texture_read_reply *ret;
+
+ if (!header)
+ return NULL;
+ if (header->opcode != (int16_t)RBUG_OP_TEXTURE_READ_REPLY)
+ return NULL;
+
+ pos = 0;
+ len = header->length * 4;
+ data = (uint8_t*)&header[1];
+ ret = MALLOC(sizeof(*ret));
+ if (!ret)
+ return NULL;
+
+ ret->header.__message = header;
+ ret->header.opcode = header->opcode;
+
+ READ(4, uint32_t, serial); /* serial */
+ READ(4, uint32_t, format); /* format */
+ READ(4, uint32_t, blockw); /* blockw */
+ READ(4, uint32_t, blockh); /* blockh */
+ READ(4, uint32_t, blocksize); /* blocksize */
+ READ_ARRAY(1, uint8_t, data); /* data */
+ READ(4, uint32_t, stride); /* stride */
+
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * This file holds structs decelerations and function prototypes for one of
+ * the rbug extensions. Implementation of the functions is in the same folder
+ * in the c file matching this file's name.
+ *
+ * The structs what is returned from the demarshal functions. The functions
+ * starting rbug_send_* encodes a call to the write format and sends that to
+ * the supplied connection, while functions starting with rbug_demarshal_*
+ * demarshal data from the wire protocol.
+ *
+ * Structs and functions ending with _reply are replies to requests.
+ */
+
+#ifndef _RBUG_PROTO_TEXTURE_H_
+#define _RBUG_PROTO_TEXTURE_H_
+
+#include "rbug/rbug_proto.h"
+
+typedef uint64_t rbug_texture_t;
+
+struct rbug_proto_texture_list
+{
+ struct rbug_header header;
+};
+
+struct rbug_proto_texture_info
+{
+ struct rbug_header header;
+ rbug_texture_t texture;
+};
+
+struct rbug_proto_texture_write
+{
+ struct rbug_header header;
+ 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;
+};
+
+struct rbug_proto_texture_read
+{
+ struct rbug_header header;
+ 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;
+};
+
+struct rbug_proto_texture_list_reply
+{
+ struct rbug_header header;
+ uint32_t serial;
+ rbug_texture_t *textures;
+ uint32_t textures_len;
+};
+
+struct rbug_proto_texture_info_reply
+{
+ struct rbug_header header;
+ 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;
+};
+
+struct rbug_proto_texture_read_reply
+{
+ struct rbug_header header;
+ 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;
+};
+
+int rbug_send_texture_list(struct rbug_connection *__con,
+ uint32_t *__serial);
+
+int rbug_send_texture_info(struct rbug_connection *__con,
+ rbug_texture_t texture,
+ uint32_t *__serial);
+
+int 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);
+
+int 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);
+
+int rbug_send_texture_list_reply(struct rbug_connection *__con,
+ uint32_t serial,
+ rbug_texture_t *textures,
+ uint32_t textures_len,
+ uint32_t *__serial);
+
+int 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);
+
+int 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);
+
+struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header);
+
+struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header);
+
+#endif
OSDN Git Service
