rbug: Add Gallium Remote Debugger Protocol code

This is the (de)marshalling and connection managment code

configs/default

@@ -90,7 +90,7 @@ EGL_DRIVERS_DIRS = demo
 
 # 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)

configure.ac

@@ -409,7 +409,7 @@ WINDOW_SYSTEM=""
 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=""
 

src/gallium/SConscript

@@ -22,6 +22,7 @@ SConscript([
 	'auxiliary/draw/SConscript',
 	'auxiliary/pipebuffer/SConscript',
 	'auxiliary/indices/SConscript',
+	'auxiliary/rbug/SConscript',
 ])
 
 for driver in env['drivers']:

src/gallium/auxiliary/rbug/Makefile

@@ -0,0 +1,14 @@
+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

src/gallium/auxiliary/rbug/README

@@ -0,0 +1,21 @@
+                 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>

src/gallium/auxiliary/rbug/SConscript

@@ -0,0 +1,14 @@
+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)

src/gallium/auxiliary/rbug/rbug.h

@@ -0,0 +1,33 @@
+/*
+ * 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"

src/gallium/auxiliary/rbug/rbug_connection.c

@@ -0,0 +1,167 @@
+/*
+ * 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;
+}

src/gallium/auxiliary/rbug/rbug_connection.h

@@ -0,0 +1,45 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_context.c

@@ -0,0 +1,442 @@
+/*
+ * 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;
+}

src/gallium/auxiliary/rbug/rbug_context.h

@@ -0,0 +1,128 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_core.c

@@ -0,0 +1,359 @@
+/*
+ * 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;
+}

src/gallium/auxiliary/rbug/rbug_core.h

@@ -0,0 +1,101 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_demarshal.c

@@ -0,0 +1,85 @@
+/*
+ * 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;
+	}
+}

src/gallium/auxiliary/rbug/rbug_internal.h

@@ -0,0 +1,100 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_proto.h

@@ -0,0 +1,90 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_shader.c

@@ -0,0 +1,468 @@
+/*
+ * 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;
+}

src/gallium/auxiliary/rbug/rbug_shader.h

@@ -0,0 +1,144 @@
+/*
+ * 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

src/gallium/auxiliary/rbug/rbug_texture.c

@@ -0,0 +1,631 @@
+/*
+ * 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;
+}

src/gallium/auxiliary/rbug/rbug_texture.h

@@ -0,0 +1,207 @@
+/*
+ * 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