trace: Make stream a global variable.

This not only simplifies the code, but allows to use atexit() to ensure
the log is closed when applications don't exit cleanly.

12 files changed, 906 insertions, 1017 deletions

diff --git a/src/gallium/drivers/trace/README b/src/gallium/drivers/trace/README
index 4b763f2488..5752448b93 100644
--- a/src/gallium/drivers/trace/README
+++ b/src/gallium/drivers/trace/README
@@ -20,16 +20,7 @@ and then try running
 
 which should create a gallium.*.trace file, which is an XML file. You can view 
 copying trace.xsl and trace.css to the same directory, and opening with a 
-XSLT capable browser like Firefox or Internet Explorer. It often happens that 
-the trace file was not properly terminated, and a
-
- </trace>
- 
-closing tag is missing from the file end. Add it before try to open or 
-further transform it by doing
-
-  echo '</trace>' >> gallium.??.trace
-
+XSLT capable browser like Firefox or Internet Explorer.
 
 This is still work in progress, namely:
 - surface writes are not traced
diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c
index e43fc01c55..868b4f010d 100644
--- a/src/gallium/drivers/trace/tr_context.c
+++ b/src/gallium/drivers/trace/tr_context.c
@@ -26,12 +26,10 @@
  **************************************************************************/
 
 #include "pipe/p_util.h"
+#include "pipe/p_screen.h"
 
-#include "tr_stream.h"
 #include "tr_dump.h"
 #include "tr_state.h"
-#include "tr_winsys.h"
-#include "tr_screen.h"
 #include "tr_context.h"
 
 
@@ -40,18 +38,17 @@ trace_context_set_edgeflags(struct pipe_context *_pipe,
                             const unsigned *bitfield)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_edgeflags");
+   trace_dump_call_begin("pipe_context", "set_edgeflags");
    
-   trace_dump_arg(stream, ptr, pipe);
+   trace_dump_arg(ptr, pipe);
    /* FIXME: we don't know how big this array is */
-   trace_dump_arg(stream, ptr, bitfield);
+   trace_dump_arg(ptr, bitfield);
 
    pipe->set_edgeflags(pipe, bitfield);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -60,22 +57,21 @@ trace_context_draw_arrays(struct pipe_context *_pipe,
                           unsigned mode, unsigned start, unsigned count)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    boolean result;
 
-   trace_dump_call_begin(stream, "pipe_context", "draw_arrays");
+   trace_dump_call_begin("pipe_context", "draw_arrays");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, mode);
-   trace_dump_arg(stream, uint, start);
-   trace_dump_arg(stream, uint, count);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, mode);
+   trace_dump_arg(uint, start);
+   trace_dump_arg(uint, count);
 
    result = pipe->draw_arrays(pipe, mode, start, count);;
 
-   trace_dump_ret(stream, bool, result);
+   trace_dump_ret(bool, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -88,24 +84,23 @@ trace_context_draw_elements(struct pipe_context *_pipe,
                           unsigned mode, unsigned start, unsigned count)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    boolean result;
 
-   trace_dump_call_begin(stream, "pipe_context", "draw_elements");
+   trace_dump_call_begin("pipe_context", "draw_elements");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, indexBuffer);
-   trace_dump_arg(stream, uint, indexSize);
-   trace_dump_arg(stream, uint, mode);
-   trace_dump_arg(stream, uint, start);
-   trace_dump_arg(stream, uint, count);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, indexBuffer);
+   trace_dump_arg(uint, indexSize);
+   trace_dump_arg(uint, mode);
+   trace_dump_arg(uint, start);
+   trace_dump_arg(uint, count);
 
    result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);;
 
-   trace_dump_ret(stream, bool, result);
+   trace_dump_ret(bool, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -122,29 +117,28 @@ trace_context_draw_range_elements(struct pipe_context *_pipe,
                                   unsigned count)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    boolean result;
 
-   trace_dump_call_begin(stream, "pipe_context", "draw_range_elements");
+   trace_dump_call_begin("pipe_context", "draw_range_elements");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, indexBuffer);
-   trace_dump_arg(stream, uint, indexSize);
-   trace_dump_arg(stream, uint, minIndex);
-   trace_dump_arg(stream, uint, maxIndex);
-   trace_dump_arg(stream, uint, mode);
-   trace_dump_arg(stream, uint, start);
-   trace_dump_arg(stream, uint, count);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, indexBuffer);
+   trace_dump_arg(uint, indexSize);
+   trace_dump_arg(uint, minIndex);
+   trace_dump_arg(uint, maxIndex);
+   trace_dump_arg(uint, mode);
+   trace_dump_arg(uint, start);
+   trace_dump_arg(uint, count);
 
    result = pipe->draw_range_elements(pipe, 
                                       indexBuffer, 
                                       indexSize, minIndex, maxIndex, 
                                       mode, start, count);
    
-   trace_dump_ret(stream, bool, result);
+   trace_dump_ret(bool, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -155,20 +149,19 @@ trace_context_create_query(struct pipe_context *_pipe,
                            unsigned query_type)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    struct pipe_query *result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_query");
+   trace_dump_call_begin("pipe_context", "create_query");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, query_type);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, query_type);
 
    result = pipe->create_query(pipe, query_type);;
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -179,17 +172,16 @@ trace_context_destroy_query(struct pipe_context *_pipe,
                             struct pipe_query *query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "destroy_query");
+   trace_dump_call_begin("pipe_context", "destroy_query");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, query);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, query);
 
    pipe->destroy_query(pipe, query);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -198,17 +190,16 @@ trace_context_begin_query(struct pipe_context *_pipe,
                           struct pipe_query *query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "begin_query");
+   trace_dump_call_begin("pipe_context", "begin_query");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, query);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, query);
 
    pipe->begin_query(pipe, query);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -217,17 +208,16 @@ trace_context_end_query(struct pipe_context *_pipe,
                         struct pipe_query *query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "end_query");
+   trace_dump_call_begin("pipe_context", "end_query");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, query);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, query);
 
    pipe->end_query(pipe, query);
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -238,22 +228,21 @@ trace_context_get_query_result(struct pipe_context *_pipe,
                                uint64 *presult)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    uint64 result;
    boolean _result;
 
-   trace_dump_call_begin(stream, "pipe_context", "get_query_result");
+   trace_dump_call_begin("pipe_context", "get_query_result");
 
-   trace_dump_arg(stream, ptr, pipe);
+   trace_dump_arg(ptr, pipe);
 
    _result = pipe->get_query_result(pipe, query, wait, presult);;
    result = *presult;
 
-   trace_dump_arg(stream, uint, result);
-   trace_dump_ret(stream, bool, _result);
+   trace_dump_arg(uint, result);
+   trace_dump_ret(bool, _result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return _result;
 }
@@ -264,20 +253,19 @@ trace_context_create_blend_state(struct pipe_context *_pipe,
                                  const struct pipe_blend_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_blend_state");
+   trace_dump_call_begin("pipe_context", "create_blend_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, blend_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(blend_state, state);
 
    result = pipe->create_blend_state(pipe, state);;
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -288,17 +276,16 @@ trace_context_bind_blend_state(struct pipe_context *_pipe,
                                void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_blend_state");
+   trace_dump_call_begin("pipe_context", "bind_blend_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->bind_blend_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -307,17 +294,16 @@ trace_context_delete_blend_state(struct pipe_context *_pipe,
                                  void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_blend_state");
+   trace_dump_call_begin("pipe_context", "delete_blend_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_blend_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -326,20 +312,19 @@ trace_context_create_sampler_state(struct pipe_context *_pipe,
                                    const struct pipe_sampler_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_sampler_state");
+   trace_dump_call_begin("pipe_context", "create_sampler_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    result = pipe->create_sampler_state(pipe, state);;
 
-   trace_dump_ret(stream, sampler_state, result);
+   trace_dump_ret(sampler_state, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -350,18 +335,17 @@ trace_context_bind_sampler_states(struct pipe_context *_pipe,
                                   unsigned num_states, void **states)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_sampler_states");
+   trace_dump_call_begin("pipe_context", "bind_sampler_states");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, num_states);
-   trace_dump_arg_array(stream, ptr, states, num_states);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, num_states);
+   trace_dump_arg_array(ptr, states, num_states);
 
    pipe->bind_sampler_states(pipe, num_states, states);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -370,17 +354,16 @@ trace_context_delete_sampler_state(struct pipe_context *_pipe,
                                    void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_sampler_state");
+   trace_dump_call_begin("pipe_context", "delete_sampler_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_sampler_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -389,20 +372,19 @@ trace_context_create_rasterizer_state(struct pipe_context *_pipe,
                                       const struct pipe_rasterizer_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_rasterizer_state");
+   trace_dump_call_begin("pipe_context", "create_rasterizer_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, rasterizer_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(rasterizer_state, state);
 
    result = pipe->create_rasterizer_state(pipe, state);;
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -413,17 +395,16 @@ trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
                                     void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_rasterizer_state");
+   trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->bind_rasterizer_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -432,17 +413,16 @@ trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
                                       void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_rasterizer_state");
+   trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_rasterizer_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -451,20 +431,19 @@ trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
                                                const struct pipe_depth_stencil_alpha_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_depth_stencil_alpha_state");
+   trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
 
    result = pipe->create_depth_stencil_alpha_state(pipe, state);;
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, depth_stencil_alpha_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(depth_stencil_alpha_state, state);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -475,17 +454,16 @@ trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
                                              void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_depth_stencil_alpha_state");
+   trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->bind_depth_stencil_alpha_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -494,17 +472,16 @@ trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
                                                void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_depth_stencil_alpha_state");
+   trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_depth_stencil_alpha_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -513,20 +490,19 @@ trace_context_create_fs_state(struct pipe_context *_pipe,
                               const struct pipe_shader_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_fs_state");
+   trace_dump_call_begin("pipe_context", "create_fs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, shader_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(shader_state, state);
 
    result = pipe->create_fs_state(pipe, state);;
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -537,17 +513,16 @@ trace_context_bind_fs_state(struct pipe_context *_pipe,
                             void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_fs_state");
+   trace_dump_call_begin("pipe_context", "bind_fs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->bind_fs_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -556,17 +531,16 @@ trace_context_delete_fs_state(struct pipe_context *_pipe,
                               void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_fs_state");
+   trace_dump_call_begin("pipe_context", "delete_fs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_fs_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -575,20 +549,19 @@ trace_context_create_vs_state(struct pipe_context *_pipe,
                               const struct pipe_shader_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
    void * result;
 
-   trace_dump_call_begin(stream, "pipe_context", "create_vs_state");
+   trace_dump_call_begin("pipe_context", "create_vs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, shader_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(shader_state, state);
 
    result = pipe->create_vs_state(pipe, state);;
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -599,17 +572,16 @@ trace_context_bind_vs_state(struct pipe_context *_pipe,
                             void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "bind_vs_state");
+   trace_dump_call_begin("pipe_context", "bind_vs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->bind_vs_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -618,17 +590,16 @@ trace_context_delete_vs_state(struct pipe_context *_pipe,
                               void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "delete_vs_state");
+   trace_dump_call_begin("pipe_context", "delete_vs_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, state);
 
    pipe->delete_vs_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -637,17 +608,16 @@ trace_context_set_blend_color(struct pipe_context *_pipe,
                               const struct pipe_blend_color *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_blend_color");
+   trace_dump_call_begin("pipe_context", "set_blend_color");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, blend_color, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(blend_color, state);
 
    pipe->set_blend_color(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -656,17 +626,16 @@ trace_context_set_clip_state(struct pipe_context *_pipe,
                              const struct pipe_clip_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_clip_state");
+   trace_dump_call_begin("pipe_context", "set_clip_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, clip_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(clip_state, state);
 
    pipe->set_clip_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -676,19 +645,18 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe,
                                   const struct pipe_constant_buffer *buffer)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_constant_buffer");
+   trace_dump_call_begin("pipe_context", "set_constant_buffer");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, shader);
-   trace_dump_arg(stream, uint, index);
-   trace_dump_arg(stream, constant_buffer, buffer);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, shader);
+   trace_dump_arg(uint, index);
+   trace_dump_arg(constant_buffer, buffer);
 
    pipe->set_constant_buffer(pipe, shader, index, buffer);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -697,17 +665,16 @@ trace_context_set_framebuffer_state(struct pipe_context *_pipe,
                                     const struct pipe_framebuffer_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_framebuffer_state");
+   trace_dump_call_begin("pipe_context", "set_framebuffer_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, framebuffer_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(framebuffer_state, state);
 
    pipe->set_framebuffer_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -716,17 +683,16 @@ trace_context_set_polygon_stipple(struct pipe_context *_pipe,
                                   const struct pipe_poly_stipple *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_polygon_stipple");
+   trace_dump_call_begin("pipe_context", "set_polygon_stipple");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, poly_stipple, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(poly_stipple, state);
 
    pipe->set_polygon_stipple(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -735,17 +701,16 @@ trace_context_set_scissor_state(struct pipe_context *_pipe,
                                 const struct pipe_scissor_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_scissor_state");
+   trace_dump_call_begin("pipe_context", "set_scissor_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, scissor_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(scissor_state, state);
 
    pipe->set_scissor_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -754,17 +719,16 @@ trace_context_set_viewport_state(struct pipe_context *_pipe,
                                  const struct pipe_viewport_state *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_viewport_state");
+   trace_dump_call_begin("pipe_context", "set_viewport_state");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, viewport_state, state);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(viewport_state, state);
 
    pipe->set_viewport_state(pipe, state);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -774,18 +738,17 @@ trace_context_set_sampler_textures(struct pipe_context *_pipe,
                                    struct pipe_texture **textures)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_sampler_textures");
+   trace_dump_call_begin("pipe_context", "set_sampler_textures");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, num_textures);
-   trace_dump_arg_array(stream, ptr, textures, num_textures);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, num_textures);
+   trace_dump_arg_array(ptr, textures, num_textures);
 
    pipe->set_sampler_textures(pipe, num_textures, textures);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -795,21 +758,20 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
                                  const struct pipe_vertex_buffer *buffers)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_vertex_buffers");
+   trace_dump_call_begin("pipe_context", "set_vertex_buffers");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, num_buffers);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, num_buffers);
    
-   trace_dump_arg_begin(stream, "buffers");
-   trace_dump_struct_array(stream, vertex_buffer, buffers, num_buffers);
-   trace_dump_arg_end(stream);
+   trace_dump_arg_begin("buffers");
+   trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
+   trace_dump_arg_end();
 
    pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -819,21 +781,20 @@ trace_context_set_vertex_elements(struct pipe_context *_pipe,
                                   const struct pipe_vertex_element *elements)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "set_vertex_elements");
+   trace_dump_call_begin("pipe_context", "set_vertex_elements");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, num_elements);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, num_elements);
 
-   trace_dump_arg_begin(stream, "elements");
-   trace_dump_struct_array(stream, vertex_element, elements, num_elements);
-   trace_dump_arg_end(stream);
+   trace_dump_arg_begin("elements");
+   trace_dump_struct_array(vertex_element, elements, num_elements);
+   trace_dump_arg_end();
 
    pipe->set_vertex_elements(pipe, num_elements, elements);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -847,27 +808,26 @@ trace_context_surface_copy(struct pipe_context *_pipe,
                            unsigned width, unsigned height)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "surface_copy");
+   trace_dump_call_begin("pipe_context", "surface_copy");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, bool, do_flip);
-   trace_dump_arg(stream, ptr, dest);
-   trace_dump_arg(stream, uint, destx);
-   trace_dump_arg(stream, uint, desty);
-   trace_dump_arg(stream, ptr, src);
-   trace_dump_arg(stream, uint, srcx);
-   trace_dump_arg(stream, uint, srcy);
-   trace_dump_arg(stream, uint, width);
-   trace_dump_arg(stream, uint, height);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(bool, do_flip);
+   trace_dump_arg(ptr, dest);
+   trace_dump_arg(uint, destx);
+   trace_dump_arg(uint, desty);
+   trace_dump_arg(ptr, src);
+   trace_dump_arg(uint, srcx);
+   trace_dump_arg(uint, srcy);
+   trace_dump_arg(uint, width);
+   trace_dump_arg(uint, height);
 
    pipe->surface_copy(pipe, do_flip, 
                       dest, destx, desty, 
                       src, srcx, srcy, width, height);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -879,21 +839,20 @@ trace_context_surface_fill(struct pipe_context *_pipe,
                            unsigned value)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "surface_fill");
+   trace_dump_call_begin("pipe_context", "surface_fill");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, dst);
-   trace_dump_arg(stream, uint, dstx);
-   trace_dump_arg(stream, uint, dsty);
-   trace_dump_arg(stream, uint, width);
-   trace_dump_arg(stream, uint, height);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, dst);
+   trace_dump_arg(uint, dstx);
+   trace_dump_arg(uint, dsty);
+   trace_dump_arg(uint, width);
+   trace_dump_arg(uint, height);
 
    pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -903,18 +862,17 @@ trace_context_clear(struct pipe_context *_pipe,
                     unsigned clearValue)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "clear");
+   trace_dump_call_begin("pipe_context", "clear");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, ptr, surface);
-   trace_dump_arg(stream, uint, clearValue);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, surface);
+   trace_dump_arg(uint, clearValue);
 
    pipe->clear(pipe, surface, clearValue);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -924,18 +882,17 @@ trace_context_flush(struct pipe_context *_pipe,
                     struct pipe_fence_handle **fence)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "flush");
+   trace_dump_call_begin("pipe_context", "flush");
 
-   trace_dump_arg(stream, ptr, pipe);
-   trace_dump_arg(stream, uint, flags);
-   trace_dump_arg(stream, ptr, fence);
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, flags);
+   trace_dump_arg(ptr, fence);
 
    pipe->flush(pipe, flags, fence);;
 
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -943,16 +900,15 @@ static INLINE void
 trace_context_destroy(struct pipe_context *_pipe)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_stream *stream = tr_ctx->stream;
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin(stream, "pipe_context", "destroy");
+   trace_dump_call_begin("pipe_context", "destroy");
 
-   trace_dump_arg(stream, ptr, pipe);
+   trace_dump_arg(ptr, pipe);
 
    pipe->destroy(pipe);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 
    FREE(tr_ctx);
 }
@@ -962,15 +918,14 @@ struct pipe_context *
 trace_context_create(struct pipe_screen *screen, 
                      struct pipe_context *pipe)
 {
-   struct trace_stream *stream;
    struct trace_context *tr_ctx;
    
-   if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
-      return pipe;
+   if(!pipe)
+      goto error1;
    
    tr_ctx = CALLOC_STRUCT(trace_context);
    if(!tr_ctx)
-      return NULL;
+      goto error1;
 
    tr_ctx->base.winsys = screen->winsys;
    tr_ctx->base.screen = screen;
@@ -1018,14 +973,16 @@ trace_context_create(struct pipe_screen *screen,
    tr_ctx->base.flush = trace_context_flush;
 
    tr_ctx->pipe = pipe;
-   tr_ctx->stream = stream = trace_screen(screen)->stream;
    
-   trace_dump_call_begin(stream, "", "pipe_context_create");
-   trace_dump_arg_begin(stream, "screen");
-   trace_dump_ptr(stream, pipe->screen);
-   trace_dump_arg_end(stream);
-   trace_dump_ret(stream, ptr, pipe);
-   trace_dump_call_end(stream);
+   trace_dump_call_begin("", "pipe_context_create");
+   trace_dump_arg_begin("screen");
+   trace_dump_ptr(pipe->screen);
+   trace_dump_arg_end();
+   trace_dump_ret(ptr, pipe);
+   trace_dump_call_end();
 
    return &tr_ctx->base;
+   
+error1:
+   return pipe;
 }
diff --git a/src/gallium/drivers/trace/tr_context.h b/src/gallium/drivers/trace/tr_context.h
index 1aa822ba02..679371e310 100644
--- a/src/gallium/drivers/trace/tr_context.h
+++ b/src/gallium/drivers/trace/tr_context.h
@@ -34,16 +34,11 @@
 #include "pipe/p_context.h"
 
 
-struct trace_stream;
-
-   
 struct trace_context
 {
    struct pipe_context base;
    
    struct pipe_context *pipe;
-   
-   struct trace_stream *stream;
 };
 
 
diff --git a/src/gallium/drivers/trace/tr_dump.c b/src/gallium/drivers/trace/tr_dump.c
index 5269c4ddc8..6ebb639b7c 100644
--- a/src/gallium/drivers/trace/tr_dump.c
+++ b/src/gallium/drivers/trace/tr_dump.c
@@ -38,6 +38,11 @@
  * @author Jose Fonseca <jrfonseca@tungstengraphics.com>   
  */
 
+#include "pipe/p_config.h"
+
+#if defined(PIPE_OS_LINUX)
+#include <stdlib.h>
+#endif
 
 #include "pipe/p_compiler.h"
 #include "util/u_string.h"
@@ -46,318 +51,328 @@
 #include "tr_dump.h"
 
 
+static struct trace_stream *stream = NULL;
+
+
 static INLINE void 
-trace_dump_write(struct trace_stream *stream, const char *s)
+trace_dump_write(const char *buf, size_t size)
 {
-   trace_stream_write(stream, s, strlen(s));
+   if(stream)
+      trace_stream_write(stream, buf, size);
 }
 
 
 static INLINE void 
-trace_dump_writef(struct trace_stream *stream, const char *format, ...)
+trace_dump_writes(const char *s)
 {
-   char buf[1024];
+   trace_dump_write(s, strlen(s));
+}
+
+
+static INLINE void 
+trace_dump_writef(const char *format, ...)
+{
+   static char buf[1024];
+   unsigned len;
    va_list ap;
    va_start(ap, format);
-   util_vsnprintf(buf, sizeof(buf), format, ap);
+   len = util_vsnprintf(buf, sizeof(buf), format, ap);
    va_end(ap);
-   trace_dump_write(stream, buf);
+   trace_dump_write(buf, len);
 }
 
 
 static INLINE void 
-trace_dump_escape(struct trace_stream *stream, const char *str) 
+trace_dump_escape(const char *str) 
 {
    const unsigned char *p = (const unsigned char *)str;
    unsigned char c;
    while((c = *p++) != 0) {
       if(c == '<')
-         trace_dump_write(stream, "&lt;");
+         trace_dump_writes("&lt;");
       else if(c == '>')
-         trace_dump_write(stream, "&gt;");
+         trace_dump_writes("&gt;");
       else if(c == '&')
-         trace_dump_write(stream, "&amp;");
+         trace_dump_writes("&amp;");
       else if(c == '\'')
-         trace_dump_write(stream, "&apos;");
+         trace_dump_writes("&apos;");
       else if(c == '\"')
-         trace_dump_write(stream, "&quot;");
+         trace_dump_writes("&quot;");
       else if(c >= 0x20 && c <= 0x7e)
-         trace_dump_writef(stream, "%c", c);
+         trace_dump_writef("%c", c);
       else
-         trace_dump_writef(stream, "&#%u;", c);
+         trace_dump_writef("&#%u;", c);
    }
 }
 
 
 static INLINE void 
-trace_dump_indent(struct trace_stream *stream, unsigned level)
+trace_dump_indent(unsigned level)
 {
    unsigned i;
    for(i = 0; i < level; ++i)
-      trace_dump_write(stream, "\t");
+      trace_dump_writes("\t");
 }
 
 
 static INLINE void 
-trace_dump_newline(struct trace_stream *stream) 
+trace_dump_newline(void) 
 {
-   trace_dump_write(stream, "\n");
+   trace_dump_writes("\n");
 }
 
 
 static INLINE void 
-trace_dump_tag(struct trace_stream *stream, 
-               const char *name)
+trace_dump_tag(const char *name)
 {
-   trace_dump_write(stream, "<");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, "/>");
+   trace_dump_writes("<");
+   trace_dump_writes(name);
+   trace_dump_writes("/>");
 }
 
 
 static INLINE void 
-trace_dump_tag_begin(struct trace_stream *stream, 
-                     const char *name)
+trace_dump_tag_begin(const char *name)
 {
-   trace_dump_write(stream, "<");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, ">");
+   trace_dump_writes("<");
+   trace_dump_writes(name);
+   trace_dump_writes(">");
 }
 
 static INLINE void 
-trace_dump_tag_begin1(struct trace_stream *stream, 
-                      const char *name, 
+trace_dump_tag_begin1(const char *name, 
                       const char *attr1, const char *value1)
 {
-   trace_dump_write(stream, "<");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, " ");
-   trace_dump_write(stream, attr1);
-   trace_dump_write(stream, "='");
-   trace_dump_escape(stream, value1);
-   trace_dump_write(stream, "'>");
+   trace_dump_writes("<");
+   trace_dump_writes(name);
+   trace_dump_writes(" ");
+   trace_dump_writes(attr1);
+   trace_dump_writes("='");
+   trace_dump_escape(value1);
+   trace_dump_writes("'>");
 }
 
 
 static INLINE void 
-trace_dump_tag_begin2(struct trace_stream *stream, 
-                      const char *name, 
+trace_dump_tag_begin2(const char *name, 
                       const char *attr1, const char *value1,
                       const char *attr2, const char *value2)
 {
-   trace_dump_write(stream, "<");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, " ");
-   trace_dump_write(stream, attr1);
-   trace_dump_write(stream, "=\'");
-   trace_dump_escape(stream, value1);
-   trace_dump_write(stream, "\' ");
-   trace_dump_write(stream, attr2);
-   trace_dump_write(stream, "=\'");
-   trace_dump_escape(stream, value2);
-   trace_dump_write(stream, "\'>");
+   trace_dump_writes("<");
+   trace_dump_writes(name);
+   trace_dump_writes(" ");
+   trace_dump_writes(attr1);
+   trace_dump_writes("=\'");
+   trace_dump_escape(value1);
+   trace_dump_writes("\' ");
+   trace_dump_writes(attr2);
+   trace_dump_writes("=\'");
+   trace_dump_escape(value2);
+   trace_dump_writes("\'>");
 }
 
 
 static INLINE void 
-trace_dump_tag_begin3(struct trace_stream *stream, 
-                      const char *name, 
+trace_dump_tag_begin3(const char *name, 
                       const char *attr1, const char *value1,
                       const char *attr2, const char *value2,
                       const char *attr3, const char *value3)
 {
-   trace_dump_write(stream, "<");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, " ");
-   trace_dump_write(stream, attr1);
-   trace_dump_write(stream, "=\'");
-   trace_dump_escape(stream, value1);
-   trace_dump_write(stream, "\' ");
-   trace_dump_write(stream, attr2);
-   trace_dump_write(stream, "=\'");
-   trace_dump_escape(stream, value2);
-   trace_dump_write(stream, "\' ");
-   trace_dump_write(stream, attr3);
-   trace_dump_write(stream, "=\'");
-   trace_dump_escape(stream, value3);
-   trace_dump_write(stream, "\'>");
+   trace_dump_writes("<");
+   trace_dump_writes(name);
+   trace_dump_writes(" ");
+   trace_dump_writes(attr1);
+   trace_dump_writes("=\'");
+   trace_dump_escape(value1);
+   trace_dump_writes("\' ");
+   trace_dump_writes(attr2);
+   trace_dump_writes("=\'");
+   trace_dump_escape(value2);
+   trace_dump_writes("\' ");
+   trace_dump_writes(attr3);
+   trace_dump_writes("=\'");
+   trace_dump_escape(value3);
+   trace_dump_writes("\'>");
 }
 
 
 static INLINE void
-trace_dump_tag_end(struct trace_stream *stream, 
-                   const char *name)
-{
-   trace_dump_write(stream, "</");
-   trace_dump_write(stream, name);
-   trace_dump_write(stream, ">");
-}
-
-
-void  trace_dump_trace_begin(struct trace_stream *stream,
-                             unsigned version)
-{
-   trace_dump_write(stream, "<?xml version='1.0' encoding='UTF-8'?>\n");
-   trace_dump_write(stream, "<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
-   trace_dump_writef(stream, "<trace version='%u'>\n", version);
-}
-
-
-void trace_dump_trace_end(struct trace_stream *stream)
-{
-   trace_dump_write(stream, "</trace>\n");
+trace_dump_tag_end(const char *name)
+{
+   trace_dump_writes("</");
+   trace_dump_writes(name);
+   trace_dump_writes(">");
+}
+
+boolean trace_dump_trace_begin()
+{
+   if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
+      return FALSE;
+   
+   stream = trace_stream_create("gallium", "trace");
+   if(!stream)
+      return FALSE;
+   
+   trace_dump_writes("<?xml version='1.0' encoding='UTF-8'?>\n");
+   trace_dump_writes("<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
+   trace_dump_writes("<trace version='0.1'>\n");
+   
+#if defined(PIPE_OS_LINUX)
+   /* Linux applications rarely cleanup GL / Gallium resources so catch 
+    * application exit here */ 
+   atexit(trace_dump_trace_end);
+#endif
+   
+   return TRUE;
+}
+
+void trace_dump_trace_end(void)
+{
+   if(stream) {
+      trace_dump_writes("</trace>\n");
+      trace_stream_close(stream);
+      stream = NULL;
+   }
 }
 
-void trace_dump_call_begin(struct trace_stream *stream,
-                           const char *klass, const char *method)
+void trace_dump_call_begin(const char *klass, const char *method)
 {
-   trace_dump_indent(stream, 1);
-   trace_dump_tag_begin2(stream, "call", "class", klass, "method", method);
-   trace_dump_newline(stream);
+   trace_dump_indent(1);
+   trace_dump_tag_begin2("call", "class", klass, "method", method);
+   trace_dump_newline();
 }
 
-void trace_dump_call_end(struct trace_stream *stream)
+void trace_dump_call_end(void)
 {
-   trace_dump_indent(stream, 1);
-   trace_dump_tag_end(stream, "call");
-   trace_dump_newline(stream);
+   trace_dump_indent(1);
+   trace_dump_tag_end("call");
+   trace_dump_newline();
 }
 
-void trace_dump_arg_begin(struct trace_stream *stream,
-                          const char *name)
+void trace_dump_arg_begin(const char *name)
 {
-   trace_dump_indent(stream, 2);
-   trace_dump_tag_begin1(stream, "arg", "name", name);
+   trace_dump_indent(2);
+   trace_dump_tag_begin1("arg", "name", name);
 }
 
-void trace_dump_arg_end(struct trace_stream *stream)
+void trace_dump_arg_end(void)
 {
-   trace_dump_tag_end(stream, "arg");
-   trace_dump_newline(stream);
+   trace_dump_tag_end("arg");
+   trace_dump_newline();
 }
 
-void trace_dump_ret_begin(struct trace_stream *stream)
+void trace_dump_ret_begin(void)
 {
-   trace_dump_indent(stream, 2);
-   trace_dump_tag_begin(stream, "ret");
+   trace_dump_indent(2);
+   trace_dump_tag_begin("ret");
 }
 
-void trace_dump_ret_end(struct trace_stream *stream)
+void trace_dump_ret_end(void)
 {
-   trace_dump_tag_end(stream, "ret");
-   trace_dump_newline(stream);
+   trace_dump_tag_end("ret");
+   trace_dump_newline();
 }
 
-void trace_dump_bool(struct trace_stream *stream, 
-                     int value)
+void trace_dump_bool(int value)
 {
-   trace_dump_writef(stream, "<bool>%c</bool>", value ? '1' : '0');
+   trace_dump_writef("<bool>%c</bool>", value ? '1' : '0');
 }
 
-void trace_dump_int(struct trace_stream *stream, 
-                    long int value)
+void trace_dump_int(long int value)
 {
-   trace_dump_writef(stream, "<int>%li</int>", value);
+   trace_dump_writef("<int>%li</int>", value);
 }
 
-void trace_dump_uint(struct trace_stream *stream, 
-                     long unsigned value)
+void trace_dump_uint(long unsigned value)
 {
-   trace_dump_writef(stream, "<uint>%lu</uint>", value);
+   trace_dump_writef("<uint>%lu</uint>", value);
 }
 
-void trace_dump_float(struct trace_stream *stream, 
-                      double value)
+void trace_dump_float(double value)
 {
-   trace_dump_writef(stream, "<float>%g</float>", value);
+   trace_dump_writef("<float>%g</float>", value);
 }
 
-void trace_dump_bytes(struct trace_stream *stream, 
-                      const void *data,
+void trace_dump_bytes(const void *data,
                       long unsigned size)
 {
    static const char hex_table[16] = "0123456789ABCDEF";
    const uint8_t *p = data;
    long unsigned i;
-   trace_dump_write(stream, "<bytes>");
+   trace_dump_writes("<bytes>");
    for(i = 0; i < size; ++i) {
       uint8_t byte = *p++;
       char hex[2];
       hex[0] = hex_table[byte >> 4];
       hex[1] = hex_table[byte & 0xf];
-      trace_stream_write(stream, hex, 2);
+      trace_dump_write(hex, 2);
    }
-   trace_dump_write(stream, "</bytes>");
+   trace_dump_writes("</bytes>");
 }
 
-void trace_dump_string(struct trace_stream *stream, 
-                       const char *str)
+void trace_dump_string(const char *str)
 {
-   trace_dump_write(stream, "<string>");
-   trace_dump_escape(stream, str);
-   trace_dump_write(stream, "</string>");
+   trace_dump_writes("<string>");
+   trace_dump_escape(str);
+   trace_dump_writes("</string>");
 }
 
-void trace_dump_enum(struct trace_stream *stream, 
-                     const char *value)
+void trace_dump_enum(const char *value)
 {
-   trace_dump_write(stream, "<enum>");
-   trace_dump_escape(stream, value);
-   trace_dump_write(stream, "</enum>");
+   trace_dump_writes("<enum>");
+   trace_dump_escape(value);
+   trace_dump_writes("</enum>");
 }
 
-void trace_dump_array_begin(struct trace_stream *stream)
+void trace_dump_array_begin(void)
 {
-   trace_dump_write(stream, "<array>");
+   trace_dump_writes("<array>");
 }
 
-void trace_dump_array_end(struct trace_stream *stream)
+void trace_dump_array_end(void)
 {
-   trace_dump_write(stream, "</array>");
+   trace_dump_writes("</array>");
 }
 
-void trace_dump_elem_begin(struct trace_stream *stream)
+void trace_dump_elem_begin(void)
 {
-   trace_dump_write(stream, "<elem>");
+   trace_dump_writes("<elem>");
 }
 
-void trace_dump_elem_end(struct trace_stream *stream)
+void trace_dump_elem_end(void)
 {
-   trace_dump_write(stream, "</elem>");
+   trace_dump_writes("</elem>");
 }
 
-void trace_dump_struct_begin(struct trace_stream *stream, 
-                             const char *name)
+void trace_dump_struct_begin(const char *name)
 {
-   trace_dump_writef(stream, "<struct name='%s'>", name);
+   trace_dump_writef("<struct name='%s'>", name);
 }
 
-void trace_dump_struct_end(struct trace_stream *stream)
+void trace_dump_struct_end(void)
 {
-   trace_dump_write(stream, "</struct>");
+   trace_dump_writes("</struct>");
 }
 
-void trace_dump_member_begin(struct trace_stream *stream, 
-                             const char *name)
+void trace_dump_member_begin(const char *name)
 {
-   trace_dump_writef(stream, "<member name='%s'>", name);
+   trace_dump_writef("<member name='%s'>", name);
 }
 
-void trace_dump_member_end(struct trace_stream *stream)
+void trace_dump_member_end(void)
 {
-   trace_dump_write(stream, "</member>");
+   trace_dump_writes("</member>");
 }
 
-void trace_dump_null(struct trace_stream *stream)
+void trace_dump_null(void)
 {
-   trace_dump_write(stream, "<null/>");
+   trace_dump_writes("<null/>");
 }
 
-void trace_dump_ptr(struct trace_stream *stream, 
-                    const void *value)
+void trace_dump_ptr(const void *value)
 {
    if(value)
-      trace_dump_writef(stream, "<ptr>%p</ptr>", value);
+      trace_dump_writef("<ptr>%p</ptr>", value);
    else
-      trace_dump_null(stream);
+      trace_dump_null();
 }
diff --git a/src/gallium/drivers/trace/tr_dump.h b/src/gallium/drivers/trace/tr_dump.h
index b2367c3288..0beb1023b1 100644
--- a/src/gallium/drivers/trace/tr_dump.h
+++ b/src/gallium/drivers/trace/tr_dump.h
@@ -4,7 +4,7 @@
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
@@ -34,100 +34,98 @@
 #define TR_DUMP_H
 
 
+#include "pipe/p_compiler.h"
 #include "pipe/p_util.h"
 
 
-struct trace_stream;
-
-
-void trace_dump_trace_begin(struct trace_stream *stream, unsigned version);
-void trace_dump_trace_end(struct trace_stream *stream);
-void trace_dump_call_begin(struct trace_stream *stream, const char *klass, const char *method);
-void trace_dump_call_end(struct trace_stream *stream);
-void trace_dump_arg_begin(struct trace_stream *stream, const char *name);
-void trace_dump_arg_end(struct trace_stream *stream);
-void trace_dump_ret_begin(struct trace_stream *stream);
-void trace_dump_ret_end(struct trace_stream *stream);
-void trace_dump_bool(struct trace_stream *stream, int value);
-void trace_dump_int(struct trace_stream *stream, long int value);
-void trace_dump_uint(struct trace_stream *stream, long unsigned value);
-void trace_dump_float(struct trace_stream *stream, double value);
-void trace_dump_bytes(struct trace_stream *stream, const void *data, long unsigned size);
-void trace_dump_string(struct trace_stream *stream, const char *str);
-void trace_dump_enum(struct trace_stream *stream, const char *value);
-void trace_dump_array_begin(struct trace_stream *stream);
-void trace_dump_array_end(struct trace_stream *stream);
-void trace_dump_elem_begin(struct trace_stream *stream);
-void trace_dump_elem_end(struct trace_stream *stream);
-void trace_dump_struct_begin(struct trace_stream *stream, const char *name);
-void trace_dump_struct_end(struct trace_stream *stream);
-void trace_dump_member_begin(struct trace_stream *stream, const char *name);
-void trace_dump_member_end(struct trace_stream *stream);
-void trace_dump_null(struct trace_stream *stream);
-void trace_dump_ptr(struct trace_stream *stream, const void *value);
+boolean trace_dump_trace_begin(void);
+void trace_dump_trace_end(void);
+void trace_dump_call_begin(const char *klass, const char *method);
+void trace_dump_call_end(void);
+void trace_dump_arg_begin(const char *name);
+void trace_dump_arg_end(void);
+void trace_dump_ret_begin(void);
+void trace_dump_ret_end(void);
+void trace_dump_bool(int value);
+void trace_dump_int(long int value);
+void trace_dump_uint(long unsigned value);
+void trace_dump_float(double value);
+void trace_dump_bytes(const void *data, long unsigned size);
+void trace_dump_string(const char *str);
+void trace_dump_enum(const char *value);
+void trace_dump_array_begin(void);
+void trace_dump_array_end(void);
+void trace_dump_elem_begin(void);
+void trace_dump_elem_end(void);
+void trace_dump_struct_begin(const char *name);
+void trace_dump_struct_end(void);
+void trace_dump_member_begin(const char *name);
+void trace_dump_member_end(void);
+void trace_dump_null(void);
+void trace_dump_ptr(const void *value);
 
 
 /*
  * Code saving macros. 
  */
 
-#define trace_dump_arg(_stream, _type, _arg) \
+#define trace_dump_arg(_type, _arg) \
    do { \
-      trace_dump_arg_begin(_stream, #_arg); \
-      trace_dump_##_type(_stream, _arg); \
-      trace_dump_arg_end(_stream); \
+      trace_dump_arg_begin(#_arg); \
+      trace_dump_##_type(_arg); \
+      trace_dump_arg_end(); \
    } while(0)
 
-#define trace_dump_ret(_stream, _type, _arg) \
+#define trace_dump_ret(_type, _arg) \
    do { \
-      trace_dump_ret_begin(_stream); \
-      trace_dump_##_type(_stream, _arg); \
-      trace_dump_ret_end(_stream); \
+      trace_dump_ret_begin(); \
+      trace_dump_##_type(_arg); \
+      trace_dump_ret_end(); \
    } while(0)
 
-#define trace_dump_array(_stream, _type, _obj, _size) \
+#define trace_dump_array(_type, _obj, _size) \
    do { \
       unsigned long idx; \
-      trace_dump_array_begin(_stream); \
+      trace_dump_array_begin(); \
       for(idx = 0; idx < (_size); ++idx) { \
-         trace_dump_elem_begin(_stream); \
-         trace_dump_##_type(_stream, (_obj)[idx]); \
-         trace_dump_elem_end(_stream); \
+         trace_dump_elem_begin(); \
+         trace_dump_##_type((_obj)[idx]); \
+         trace_dump_elem_end(); \
       } \
-      trace_dump_array_end(_stream); \
+      trace_dump_array_end(); \
    } while(0)
 
-#define trace_dump_struct_array(_stream, _type, _obj, _size) \
+#define trace_dump_struct_array(_type, _obj, _size) \
    do { \
       unsigned long idx; \
-      trace_dump_array_begin(_stream); \
+      trace_dump_array_begin(); \
       for(idx = 0; idx < (_size); ++idx) { \
-         trace_dump_elem_begin(_stream); \
-         trace_dump_##_type(_stream, &(_obj)[idx]); \
-         trace_dump_elem_end(_stream); \
+         trace_dump_elem_begin(); \
+         trace_dump_##_type(&(_obj)[idx]); \
+         trace_dump_elem_end(); \
       } \
-      trace_dump_array_end(_stream); \
+      trace_dump_array_end(); \
    } while(0)
 
-#define trace_dump_member(_stream, _type, _obj, _member) \
+#define trace_dump_member(_type, _obj, _member) \
    do { \
-      trace_dump_member_begin(_stream, #_member); \
-      trace_dump_##_type(_stream, (_obj)->_member); \
-      trace_dump_member_end(_stream); \
+      trace_dump_member_begin(#_member); \
+      trace_dump_##_type((_obj)->_member); \
+      trace_dump_member_end(); \
    } while(0)
 
-#define trace_dump_arg_array(_stream, _type, _arg, _size) \
+#define trace_dump_arg_array(_type, _arg, _size) \
    do { \
-      trace_dump_arg_begin(_stream, #_arg); \
-      trace_dump_array(_stream, _type, _arg, _size); \
-      trace_dump_arg_end(_stream); \
+      trace_dump_arg_begin(#_arg); \
+      trace_dump_array(_type, _arg, _size); \
+      trace_dump_arg_end(); \
    } while(0)
 
-#define trace_dump_member_array(_stream, _type, _obj, _member) \
+#define trace_dump_member_array(_type, _obj, _member) \
    do { \
-      trace_dump_member_begin(_stream, #_member); \
-      trace_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
-      trace_dump_member_end(_stream); \
+      trace_dump_member_begin(#_member); \
+      trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
+      trace_dump_member_end(); \
    } while(0)
 
 
diff --git a/src/gallium/drivers/trace/tr_screen.c b/src/gallium/drivers/trace/tr_screen.c
index 0e253123ae..68165a4553 100644
--- a/src/gallium/drivers/trace/tr_screen.c
+++ b/src/gallium/drivers/trace/tr_screen.c
@@ -27,7 +27,6 @@
 
 #include "pipe/p_util.h"
 
-#include "tr_stream.h"
 #include "tr_dump.h"
 #include "tr_state.h"
 #include "tr_winsys.h"
@@ -38,19 +37,18 @@ static const char *
 trace_screen_get_name(struct pipe_screen *_screen)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "get_name");
+   trace_dump_call_begin("pipe_screen", "get_name");
    
-   trace_dump_arg(stream, ptr, screen);
+   trace_dump_arg(ptr, screen);
 
    result = screen->get_name(screen);
    
-   trace_dump_ret(stream, string, result);
+   trace_dump_ret(string, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -60,19 +58,18 @@ static const char *
 trace_screen_get_vendor(struct pipe_screen *_screen)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "get_vendor");
+   trace_dump_call_begin("pipe_screen", "get_vendor");
    
-   trace_dump_arg(stream, ptr, screen);
+   trace_dump_arg(ptr, screen);
   
    result = screen->get_vendor(screen);
    
-   trace_dump_ret(stream, string, result);
+   trace_dump_ret(string, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -83,20 +80,19 @@ trace_screen_get_param(struct pipe_screen *_screen,
                        int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    int result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "get_param");
+   trace_dump_call_begin("pipe_screen", "get_param");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, int, param);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(int, param);
 
    result = screen->get_param(screen, param);
    
-   trace_dump_ret(stream, int, result);
+   trace_dump_ret(int, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -107,20 +103,19 @@ trace_screen_get_paramf(struct pipe_screen *_screen,
                         int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    float result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "get_paramf");
+   trace_dump_call_begin("pipe_screen", "get_paramf");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, int, param);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(int, param);
 
    result = screen->get_paramf(screen, param);
    
-   trace_dump_ret(stream, float, result);
+   trace_dump_ret(float, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -134,23 +129,22 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
                                  unsigned geom_flags)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    boolean result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "is_format_supported");
+   trace_dump_call_begin("pipe_screen", "is_format_supported");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, format, format);
-   trace_dump_arg(stream, int, target);
-   trace_dump_arg(stream, uint, tex_usage);
-   trace_dump_arg(stream, uint, geom_flags);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(format, format);
+   trace_dump_arg(int, target);
+   trace_dump_arg(uint, tex_usage);
+   trace_dump_arg(uint, geom_flags);
 
    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
    
-   trace_dump_ret(stream, bool, result);
+   trace_dump_ret(bool, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -161,20 +155,19 @@ trace_screen_texture_create(struct pipe_screen *_screen,
                             const struct pipe_texture *templat)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_texture *result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "texture_create");
+   trace_dump_call_begin("pipe_screen", "texture_create");
 
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, template, templat);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(template, templat);
 
    result = screen->texture_create(screen, templat);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -187,23 +180,22 @@ trace_screen_texture_blanket(struct pipe_screen *_screen,
                              struct pipe_buffer *buffer)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    unsigned pitch = *ppitch;
    struct pipe_texture *result;
 
-   trace_dump_call_begin(stream, "pipe_screen", "texture_blanket");
+   trace_dump_call_begin("pipe_screen", "texture_blanket");
 
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, template, templat);
-   trace_dump_arg(stream, uint, pitch);
-   trace_dump_arg(stream, ptr, buffer);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(template, templat);
+   trace_dump_arg(uint, pitch);
+   trace_dump_arg(ptr, buffer);
 
    result = screen->texture_blanket(screen, templat, ppitch, buffer);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -214,18 +206,17 @@ trace_screen_texture_release(struct pipe_screen *_screen,
                              struct pipe_texture **ptexture)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_texture *texture = *ptexture;
    
-   trace_dump_call_begin(stream, "pipe_screen", "texture_release");
+   trace_dump_call_begin("pipe_screen", "texture_release");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, ptr, texture);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
 
    screen->texture_release(screen, ptexture);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 static struct pipe_surface *
@@ -236,24 +227,23 @@ trace_screen_get_tex_surface(struct pipe_screen *_screen,
                              unsigned usage)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_surface *result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "get_tex_surface");
+   trace_dump_call_begin("pipe_screen", "get_tex_surface");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, ptr, texture);
-   trace_dump_arg(stream, uint, face);
-   trace_dump_arg(stream, uint, level);
-   trace_dump_arg(stream, uint, zslice);
-   trace_dump_arg(stream, uint, usage);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
+   trace_dump_arg(uint, face);
+   trace_dump_arg(uint, level);
+   trace_dump_arg(uint, zslice);
+   trace_dump_arg(uint, usage);
 
    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -264,18 +254,17 @@ trace_screen_tex_surface_release(struct pipe_screen *_screen,
                                  struct pipe_surface **psurface)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_surface *surface = *psurface;
    
-   trace_dump_call_begin(stream, "pipe_screen", "tex_surface_release");
+   trace_dump_call_begin("pipe_screen", "tex_surface_release");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, ptr, surface);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
 
    screen->tex_surface_release(screen, psurface);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -285,21 +274,20 @@ trace_screen_surface_map(struct pipe_screen *_screen,
                          unsigned flags)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_surface *result;
    
-   trace_dump_call_begin(stream, "pipe_screen", "surface_map");
+   trace_dump_call_begin("pipe_screen", "surface_map");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, ptr, surface);
-   trace_dump_arg(stream, uint, flags);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
+   trace_dump_arg(uint, flags);
 
    result = screen->surface_map(screen, surface, flags);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -310,17 +298,16 @@ trace_screen_surface_unmap(struct pipe_screen *_screen,
                            struct pipe_surface *surface)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    
-   trace_dump_call_begin(stream, "pipe_screen", "surface_unmap");
+   trace_dump_call_begin("pipe_screen", "surface_unmap");
    
-   trace_dump_arg(stream, ptr, screen);
-   trace_dump_arg(stream, ptr, surface);
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
 
    screen->surface_unmap(screen, surface);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -328,20 +315,17 @@ static void
 trace_screen_destroy(struct pipe_screen *_screen)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_stream *stream = tr_scr->stream;
    struct pipe_screen *screen = tr_scr->screen;
    
-   trace_dump_call_begin(stream, "pipe_screen", "destroy");
+   trace_dump_call_begin("pipe_screen", "destroy");
    
-   trace_dump_arg(stream, ptr, screen);
+   trace_dump_arg(ptr, screen);
 
    screen->destroy(screen);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 
-   trace_dump_trace_end(stream);
-
-   trace_stream_close(stream);
+   trace_dump_trace_end();
 
    FREE(tr_scr);
 }
@@ -350,26 +334,22 @@ trace_screen_destroy(struct pipe_screen *_screen)
 struct pipe_screen *
 trace_screen_create(struct pipe_screen *screen)
 {
-   struct trace_stream *stream;
    struct trace_screen *tr_scr;
    struct pipe_winsys *winsys;
    
-   if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
-      return screen;
-   
-   tr_scr = CALLOC_STRUCT(trace_screen);
-   if(!tr_scr)
-      return NULL;
+   if(!screen)
+      goto error1;
 
-   tr_scr->stream = stream = trace_stream_create("gallium", "trace");
-   if(!tr_scr->stream)
-      return NULL;
+   if(!trace_dump_trace_begin())
+      goto error1;
 
-   trace_dump_trace_begin(stream, 0);
+   tr_scr = CALLOC_STRUCT(trace_screen);
+   if(!tr_scr)
+      goto error2;
 
-   winsys = trace_winsys_create(stream, screen->winsys);
+   winsys = trace_winsys_create(screen->winsys);
    if(!winsys)
-      return NULL;
+      goto error3;
    
    tr_scr->base.winsys = winsys;
    tr_scr->base.destroy = trace_screen_destroy;
@@ -387,14 +367,20 @@ trace_screen_create(struct pipe_screen *screen)
    tr_scr->base.surface_unmap = trace_screen_surface_unmap;
    
    tr_scr->screen = screen;
-   tr_scr->stream = stream = trace_winsys(winsys)->stream;
 
-   trace_dump_call_begin(stream, "", "pipe_screen_create");
-   trace_dump_arg_begin(stream, "winsys");
-   trace_dump_ptr(stream, screen->winsys);
-   trace_dump_arg_end(stream);
-   trace_dump_ret(stream, ptr, screen);
-   trace_dump_call_end(stream);
+   trace_dump_call_begin("", "pipe_screen_create");
+   trace_dump_arg_begin("winsys");
+   trace_dump_ptr(screen->winsys);
+   trace_dump_arg_end();
+   trace_dump_ret(ptr, screen);
+   trace_dump_call_end();
 
    return &tr_scr->base;
+
+error3:
+   FREE(tr_scr);
+error2:
+   trace_dump_trace_end();
+error1:
+   return screen;
 }
diff --git a/src/gallium/drivers/trace/tr_screen.h b/src/gallium/drivers/trace/tr_screen.h
index 40b844778f..446c4af6a6 100644
--- a/src/gallium/drivers/trace/tr_screen.h
+++ b/src/gallium/drivers/trace/tr_screen.h
@@ -34,16 +34,11 @@
 #include "pipe/p_screen.h"
 
 
-struct trace_stream;
-
-
 struct trace_screen
 {
    struct pipe_screen base;
    
    struct pipe_screen *screen;
-   
-   struct trace_stream *stream;
 };
 
 
diff --git a/src/gallium/drivers/trace/tr_state.c b/src/gallium/drivers/trace/tr_state.c
index e074ae7abc..7b35e89e75 100644
--- a/src/gallium/drivers/trace/tr_state.c
+++ b/src/gallium/drivers/trace/tr_state.c
@@ -33,461 +33,442 @@
 #include "tr_state.h"
 
 
-void trace_dump_format(struct trace_stream *stream, 
-                       enum pipe_format format)
+void trace_dump_format(enum pipe_format format)
 {
-   trace_dump_enum(stream, pf_name(format) );
+   trace_dump_enum(pf_name(format) );
 }
 
 
-void trace_dump_block(struct trace_stream *stream, 
-                      const struct pipe_format_block *block)
+void trace_dump_block(const struct pipe_format_block *block)
 {
-   trace_dump_struct_begin(stream, "pipe_format_block");
-   trace_dump_member(stream, uint, block, size);
-   trace_dump_member(stream, uint, block, width);
-   trace_dump_member(stream, uint, block, height);
-   trace_dump_struct_end(stream);
+   trace_dump_struct_begin("pipe_format_block");
+   trace_dump_member(uint, block, size);
+   trace_dump_member(uint, block, width);
+   trace_dump_member(uint, block, height);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_template(struct trace_stream *stream, 
-                         const struct pipe_texture *templat)
+void trace_dump_template(const struct pipe_texture *templat)
 {
    assert(templat);
    if(!templat) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_texture");
+   trace_dump_struct_begin("pipe_texture");
    
-   trace_dump_member(stream, int, templat, target);
-   trace_dump_member(stream, format, templat, format);
+   trace_dump_member(int, templat, target);
+   trace_dump_member(format, templat, format);
    
-   trace_dump_member_begin(stream, "width");
-   trace_dump_array(stream, uint, templat->width, 1);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("width");
+   trace_dump_array(uint, templat->width, 1);
+   trace_dump_member_end();
 
-   trace_dump_member_begin(stream, "height");
-   trace_dump_array(stream, uint, templat->height, 1);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("height");
+   trace_dump_array(uint, templat->height, 1);
+   trace_dump_member_end();
 
-   trace_dump_member_begin(stream, "depth");
-   trace_dump_array(stream, uint, templat->depth, 1);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("depth");
+   trace_dump_array(uint, templat->depth, 1);
+   trace_dump_member_end();
 
-   trace_dump_member_begin(stream, "block");
-   trace_dump_block(stream, &templat->block);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("block");
+   trace_dump_block(&templat->block);
+   trace_dump_member_end();
    
-   trace_dump_member(stream, uint, templat, last_level);
-   trace_dump_member(stream, uint, templat, tex_usage);
+   trace_dump_member(uint, templat, last_level);
+   trace_dump_member(uint, templat, tex_usage);
    
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_rasterizer_state(struct trace_stream *stream, 
-                                 const struct pipe_rasterizer_state *state)
+void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_rasterizer_state");
-
-   trace_dump_member(stream, bool, state, flatshade);
-   trace_dump_member(stream, bool, state, light_twoside);
-   trace_dump_member(stream, uint, state, front_winding);
-   trace_dump_member(stream, uint, state, cull_mode);
-   trace_dump_member(stream, uint, state, fill_cw);
-   trace_dump_member(stream, uint, state, fill_ccw);
-   trace_dump_member(stream, bool, state, offset_cw);
-   trace_dump_member(stream, bool, state, offset_ccw);
-   trace_dump_member(stream, bool, state, scissor);
-   trace_dump_member(stream, bool, state, poly_smooth);
-   trace_dump_member(stream, bool, state, poly_stipple_enable);
-   trace_dump_member(stream, bool, state, point_smooth);
-   trace_dump_member(stream, bool, state, point_sprite);
-   trace_dump_member(stream, bool, state, point_size_per_vertex);
-   trace_dump_member(stream, bool, state, multisample);
-   trace_dump_member(stream, bool, state, line_smooth);
-   trace_dump_member(stream, bool, state, line_stipple_enable);
-   trace_dump_member(stream, uint, state, line_stipple_factor);
-   trace_dump_member(stream, uint, state, line_stipple_pattern);
-   trace_dump_member(stream, bool, state, line_last_pixel);
-   trace_dump_member(stream, bool, state, bypass_clipping);
-   trace_dump_member(stream, bool, state, bypass_vs);
-   trace_dump_member(stream, bool, state, origin_lower_left);
-   trace_dump_member(stream, bool, state, flatshade_first);
-   trace_dump_member(stream, bool, state, gl_rasterization_rules);
-
-   trace_dump_member(stream, float, state, line_width);
-   trace_dump_member(stream, float, state, point_size);
-   trace_dump_member(stream, float, state, point_size_min);
-   trace_dump_member(stream, float, state, point_size_max);
-   trace_dump_member(stream, float, state, offset_units);
-   trace_dump_member(stream, float, state, offset_scale);
+   trace_dump_struct_begin("pipe_rasterizer_state");
+
+   trace_dump_member(bool, state, flatshade);
+   trace_dump_member(bool, state, light_twoside);
+   trace_dump_member(uint, state, front_winding);
+   trace_dump_member(uint, state, cull_mode);
+   trace_dump_member(uint, state, fill_cw);
+   trace_dump_member(uint, state, fill_ccw);
+   trace_dump_member(bool, state, offset_cw);
+   trace_dump_member(bool, state, offset_ccw);
+   trace_dump_member(bool, state, scissor);
+   trace_dump_member(bool, state, poly_smooth);
+   trace_dump_member(bool, state, poly_stipple_enable);
+   trace_dump_member(bool, state, point_smooth);
+   trace_dump_member(bool, state, point_sprite);
+   trace_dump_member(bool, state, point_size_per_vertex);
+   trace_dump_member(bool, state, multisample);
+   trace_dump_member(bool, state, line_smooth);
+   trace_dump_member(bool, state, line_stipple_enable);
+   trace_dump_member(uint, state, line_stipple_factor);
+   trace_dump_member(uint, state, line_stipple_pattern);
+   trace_dump_member(bool, state, line_last_pixel);
+   trace_dump_member(bool, state, bypass_clipping);
+   trace_dump_member(bool, state, bypass_vs);
+   trace_dump_member(bool, state, origin_lower_left);
+   trace_dump_member(bool, state, flatshade_first);
+   trace_dump_member(bool, state, gl_rasterization_rules);
+
+   trace_dump_member(float, state, line_width);
+   trace_dump_member(float, state, point_size);
+   trace_dump_member(float, state, point_size_min);
+   trace_dump_member(float, state, point_size_max);
+   trace_dump_member(float, state, offset_units);
+   trace_dump_member(float, state, offset_scale);
    
-   trace_dump_member_array(stream, uint, state, sprite_coord_mode);
+   trace_dump_member_array(uint, state, sprite_coord_mode);
    
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_poly_stipple(struct trace_stream *stream,
-                             const struct pipe_poly_stipple *state)
+void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_poly_stipple");
+   trace_dump_struct_begin("pipe_poly_stipple");
 
-   trace_dump_member_begin(stream, "stipple");
-   trace_dump_array(stream,
-                    uint,
+   trace_dump_member_begin("stipple");
+   trace_dump_array(uint,
                     state->stipple, 
                     Elements(state->stipple));
-   trace_dump_member_end(stream);
+   trace_dump_member_end();
    
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_viewport_state(struct trace_stream *stream,
-                               const struct pipe_viewport_state *state)
+void trace_dump_viewport_state(const struct pipe_viewport_state *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_viewport_state");
+   trace_dump_struct_begin("pipe_viewport_state");
 
-   trace_dump_member_array(stream, float, state, scale);
-   trace_dump_member_array(stream, float, state, translate);
+   trace_dump_member_array(float, state, scale);
+   trace_dump_member_array(float, state, translate);
    
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_scissor_state(struct trace_stream *stream,
-                              const struct pipe_scissor_state *state)
+void trace_dump_scissor_state(const struct pipe_scissor_state *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_scissor_state");
+   trace_dump_struct_begin("pipe_scissor_state");
 
-   trace_dump_member(stream, uint, state, minx);
-   trace_dump_member(stream, uint, state, miny);
-   trace_dump_member(stream, uint, state, maxx);
-   trace_dump_member(stream, uint, state, maxy);
+   trace_dump_member(uint, state, minx);
+   trace_dump_member(uint, state, miny);
+   trace_dump_member(uint, state, maxx);
+   trace_dump_member(uint, state, maxy);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_clip_state(struct trace_stream *stream,
-                           const struct pipe_clip_state *state)
+void trace_dump_clip_state(const struct pipe_clip_state *state)
 {
    unsigned i;
    
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_scissor_state");
+   trace_dump_struct_begin("pipe_scissor_state");
 
-   trace_dump_member_begin(stream, "ucp");
-   trace_dump_array_begin(stream);
+   trace_dump_member_begin("ucp");
+   trace_dump_array_begin();
    for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i)
-      trace_dump_array(stream, float, state->ucp[i], 4);
-   trace_dump_array_end(stream);
-   trace_dump_member_end(stream);
+      trace_dump_array(float, state->ucp[i], 4);
+   trace_dump_array_end();
+   trace_dump_member_end();
 
-   trace_dump_member(stream, uint, state, nr);
+   trace_dump_member(uint, state, nr);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_constant_buffer(struct trace_stream *stream,
-                                const struct pipe_constant_buffer *state)
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_constant_buffer");
+   trace_dump_struct_begin("pipe_constant_buffer");
 
-   trace_dump_member(stream, ptr, state, buffer);
-   trace_dump_member(stream, uint, state, size);
+   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(uint, state, size);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_shader_state(struct trace_stream *stream,
-                             const struct pipe_shader_state *state)
+void trace_dump_shader_state(const struct pipe_shader_state *state)
 {
    static char str[8192];
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
    tgsi_dump_str(state->tokens, 0, str, sizeof(str));
    
-   trace_dump_struct_begin(stream, "pipe_shader_state");
+   trace_dump_struct_begin("pipe_shader_state");
 
-   trace_dump_member_begin(stream, "tokens");
-   trace_dump_string(stream, str);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("tokens");
+   trace_dump_string(str);
+   trace_dump_member_end();
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
-                                          const struct pipe_depth_stencil_alpha_state *state)
+void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
 {
    unsigned i;
    
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
+   trace_dump_struct_begin("pipe_depth_stencil_alpha_state");
 
-   trace_dump_member_begin(stream, "depth");
-   trace_dump_struct_begin(stream, "pipe_depth_state");
-   trace_dump_member(stream, bool, &state->depth, enabled);
-   trace_dump_member(stream, bool, &state->depth, writemask);
-   trace_dump_member(stream, uint, &state->depth, func);
-   trace_dump_member(stream, bool, &state->depth, occlusion_count);
-   trace_dump_struct_end(stream);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("depth");
+   trace_dump_struct_begin("pipe_depth_state");
+   trace_dump_member(bool, &state->depth, enabled);
+   trace_dump_member(bool, &state->depth, writemask);
+   trace_dump_member(uint, &state->depth, func);
+   trace_dump_member(bool, &state->depth, occlusion_count);
+   trace_dump_struct_end();
+   trace_dump_member_end();
    
-   trace_dump_member_begin(stream, "stencil");
-   trace_dump_array_begin(stream);
+   trace_dump_member_begin("stencil");
+   trace_dump_array_begin();
    for(i = 0; i < Elements(state->stencil); ++i) {
-      trace_dump_elem_begin(stream);
-      trace_dump_struct_begin(stream, "pipe_stencil_state");
-      trace_dump_member(stream, bool, &state->stencil[i], enabled);
-      trace_dump_member(stream, uint, &state->stencil[i], func);
-      trace_dump_member(stream, uint, &state->stencil[i], fail_op);
-      trace_dump_member(stream, uint, &state->stencil[i], zpass_op);
-      trace_dump_member(stream, uint, &state->stencil[i], zfail_op);
-      trace_dump_member(stream, uint, &state->stencil[i], ref_value);    
-      trace_dump_member(stream, uint, &state->stencil[i], value_mask);
-      trace_dump_member(stream, uint, &state->stencil[i], write_mask);
-      trace_dump_struct_end(stream);
-      trace_dump_elem_end(stream);
+      trace_dump_elem_begin();
+      trace_dump_struct_begin("pipe_stencil_state");
+      trace_dump_member(bool, &state->stencil[i], enabled);
+      trace_dump_member(uint, &state->stencil[i], func);
+      trace_dump_member(uint, &state->stencil[i], fail_op);
+      trace_dump_member(uint, &state->stencil[i], zpass_op);
+      trace_dump_member(uint, &state->stencil[i], zfail_op);
+      trace_dump_member(uint, &state->stencil[i], ref_value);    
+      trace_dump_member(uint, &state->stencil[i], value_mask);
+      trace_dump_member(uint, &state->stencil[i], write_mask);
+      trace_dump_struct_end();
+      trace_dump_elem_end();
    }
-   trace_dump_array_end(stream);
-   trace_dump_member_end(stream);
-
-   trace_dump_member_begin(stream, "alpha");
-   trace_dump_struct_begin(stream, "pipe_alpha_state");
-   trace_dump_member(stream, bool, &state->alpha, enabled);
-   trace_dump_member(stream, uint, &state->alpha, func);
-   trace_dump_member(stream, float, &state->alpha, ref);
-   trace_dump_struct_end(stream);
-   trace_dump_member_end(stream);
-
-   trace_dump_struct_end(stream);
+   trace_dump_array_end();
+   trace_dump_member_end();
+
+   trace_dump_member_begin("alpha");
+   trace_dump_struct_begin("pipe_alpha_state");
+   trace_dump_member(bool, &state->alpha, enabled);
+   trace_dump_member(uint, &state->alpha, func);
+   trace_dump_member(float, &state->alpha, ref);
+   trace_dump_struct_end();
+   trace_dump_member_end();
+
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_blend_state(struct trace_stream *stream,
-                            const struct pipe_blend_state *state)
+void trace_dump_blend_state(const struct pipe_blend_state *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_blend_state");
+   trace_dump_struct_begin("pipe_blend_state");
 
-   trace_dump_member(stream, bool, state, blend_enable);
+   trace_dump_member(bool, state, blend_enable);
 
-   trace_dump_member(stream, uint, state, rgb_func);
-   trace_dump_member(stream, uint, state, rgb_src_factor);
-   trace_dump_member(stream, uint, state, rgb_dst_factor);
+   trace_dump_member(uint, state, rgb_func);
+   trace_dump_member(uint, state, rgb_src_factor);
+   trace_dump_member(uint, state, rgb_dst_factor);
 
-   trace_dump_member(stream, uint, state, alpha_func);
-   trace_dump_member(stream, uint, state, alpha_src_factor);
-   trace_dump_member(stream, uint, state, alpha_dst_factor);
+   trace_dump_member(uint, state, alpha_func);
+   trace_dump_member(uint, state, alpha_src_factor);
+   trace_dump_member(uint, state, alpha_dst_factor);
 
-   trace_dump_member(stream, bool, state, logicop_enable);
-   trace_dump_member(stream, uint, state, logicop_func);
+   trace_dump_member(bool, state, logicop_enable);
+   trace_dump_member(uint, state, logicop_func);
 
-   trace_dump_member(stream, uint, state, colormask);
-   trace_dump_member(stream, bool, state, dither);
+   trace_dump_member(uint, state, colormask);
+   trace_dump_member(bool, state, dither);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_blend_color(struct trace_stream *stream,
-                            const struct pipe_blend_color *state)
+void trace_dump_blend_color(const struct pipe_blend_color *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_blend_color");
+   trace_dump_struct_begin("pipe_blend_color");
 
-   trace_dump_member_array(stream, float, state, color);
+   trace_dump_member_array(float, state, color);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_framebuffer_state(struct trace_stream *stream,
-                                  const struct pipe_framebuffer_state *state)
+void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
 {
-   trace_dump_struct_begin(stream, "pipe_framebuffer_state");
+   trace_dump_struct_begin("pipe_framebuffer_state");
 
-   trace_dump_member(stream, uint, state, width);
-   trace_dump_member(stream, uint, state, height);
-   trace_dump_member(stream, uint, state, num_cbufs);
-   trace_dump_member_array(stream, ptr, state, cbufs);
-   trace_dump_member(stream, ptr, state, zsbuf);
+   trace_dump_member(uint, state, width);
+   trace_dump_member(uint, state, height);
+   trace_dump_member(uint, state, num_cbufs);
+   trace_dump_member_array(ptr, state, cbufs);
+   trace_dump_member(ptr, state, zsbuf);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_sampler_state(struct trace_stream *stream,
-                              const struct pipe_sampler_state *state)
+void trace_dump_sampler_state(const struct pipe_sampler_state *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_sampler_state");
-
-   trace_dump_member(stream, uint, state, wrap_s);
-   trace_dump_member(stream, uint, state, wrap_t);
-   trace_dump_member(stream, uint, state, wrap_r);
-   trace_dump_member(stream, uint, state, min_img_filter);
-   trace_dump_member(stream, uint, state, min_mip_filter);
-   trace_dump_member(stream, uint, state, mag_img_filter);
-   trace_dump_member(stream, bool, state, compare_mode);
-   trace_dump_member(stream, uint, state, compare_func);
-   trace_dump_member(stream, bool, state, normalized_coords);
-   trace_dump_member(stream, uint, state, prefilter);
-   trace_dump_member(stream, float, state, shadow_ambient);
-   trace_dump_member(stream, float, state, lod_bias);
-   trace_dump_member(stream, float, state, min_lod);
-   trace_dump_member(stream, float, state, max_lod);
-   trace_dump_member_array(stream, float, state, border_color);
-   trace_dump_member(stream, float, state, max_anisotropy);
-
-   trace_dump_struct_end(stream);
+   trace_dump_struct_begin("pipe_sampler_state");
+
+   trace_dump_member(uint, state, wrap_s);
+   trace_dump_member(uint, state, wrap_t);
+   trace_dump_member(uint, state, wrap_r);
+   trace_dump_member(uint, state, min_img_filter);
+   trace_dump_member(uint, state, min_mip_filter);
+   trace_dump_member(uint, state, mag_img_filter);
+   trace_dump_member(bool, state, compare_mode);
+   trace_dump_member(uint, state, compare_func);
+   trace_dump_member(bool, state, normalized_coords);
+   trace_dump_member(uint, state, prefilter);
+   trace_dump_member(float, state, shadow_ambient);
+   trace_dump_member(float, state, lod_bias);
+   trace_dump_member(float, state, min_lod);
+   trace_dump_member(float, state, max_lod);
+   trace_dump_member_array(float, state, border_color);
+   trace_dump_member(float, state, max_anisotropy);
+
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_surface(struct trace_stream *stream,
-                        const struct pipe_surface *state)
+void trace_dump_surface(const struct pipe_surface *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_surface");
+   trace_dump_struct_begin("pipe_surface");
 
-   trace_dump_member(stream, ptr, state, buffer);
-   trace_dump_member(stream, format, state, format);
-   trace_dump_member(stream, uint, state, status);
-   trace_dump_member(stream, uint, state, clear_value);
-   trace_dump_member(stream, uint, state, width);
-   trace_dump_member(stream, uint, state, height);
+   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(format, state, format);
+   trace_dump_member(uint, state, status);
+   trace_dump_member(uint, state, clear_value);
+   trace_dump_member(uint, state, width);
+   trace_dump_member(uint, state, height);
 
-   trace_dump_member_begin(stream, "block");
-   trace_dump_block(stream, &state->block);
-   trace_dump_member_end(stream);
+   trace_dump_member_begin("block");
+   trace_dump_block(&state->block);
+   trace_dump_member_end();
    
-   trace_dump_member(stream, uint, state, nblocksx);
-   trace_dump_member(stream, uint, state, nblocksy);
-   trace_dump_member(stream, uint, state, stride);
-   trace_dump_member(stream, uint, state, layout);
-   trace_dump_member(stream, uint, state, offset);
-   trace_dump_member(stream, uint, state, refcount);
-   trace_dump_member(stream, uint, state, usage);
-
-   trace_dump_member(stream, ptr, state, texture);
-   trace_dump_member(stream, uint, state, face);
-   trace_dump_member(stream, uint, state, level);
-   trace_dump_member(stream, uint, state, zslice);
-
-   trace_dump_struct_end(stream);
+   trace_dump_member(uint, state, nblocksx);
+   trace_dump_member(uint, state, nblocksy);
+   trace_dump_member(uint, state, stride);
+   trace_dump_member(uint, state, layout);
+   trace_dump_member(uint, state, offset);
+   trace_dump_member(uint, state, refcount);
+   trace_dump_member(uint, state, usage);
+
+   trace_dump_member(ptr, state, texture);
+   trace_dump_member(uint, state, face);
+   trace_dump_member(uint, state, level);
+   trace_dump_member(uint, state, zslice);
+
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_vertex_buffer(struct trace_stream *stream,
-                              const struct pipe_vertex_buffer *state)
+void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_vertex_buffer");
+   trace_dump_struct_begin("pipe_vertex_buffer");
 
-   trace_dump_member(stream, uint, state, pitch);
-   trace_dump_member(stream, uint, state, max_index);
-   trace_dump_member(stream, uint, state, buffer_offset);
-   trace_dump_member(stream, ptr, state, buffer);
+   trace_dump_member(uint, state, pitch);
+   trace_dump_member(uint, state, max_index);
+   trace_dump_member(uint, state, buffer_offset);
+   trace_dump_member(ptr, state, buffer);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
 
 
-void trace_dump_vertex_element(struct trace_stream *stream,
-                               const struct pipe_vertex_element *state)
+void trace_dump_vertex_element(const struct pipe_vertex_element *state)
 {
    assert(state);
    if(!state) {
-      trace_dump_null(stream);
+      trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin(stream, "pipe_vertex_element");
+   trace_dump_struct_begin("pipe_vertex_element");
 
-   trace_dump_member(stream, uint, state, src_offset);
+   trace_dump_member(uint, state, src_offset);
 
-   trace_dump_member(stream, uint, state, vertex_buffer_index);
-   trace_dump_member(stream, uint, state, nr_components);
+   trace_dump_member(uint, state, vertex_buffer_index);
+   trace_dump_member(uint, state, nr_components);
  
-   trace_dump_member(stream, format, state, src_format);
+   trace_dump_member(format, state, src_format);
 
-   trace_dump_struct_end(stream);
+   trace_dump_struct_end();
 }
diff --git a/src/gallium/drivers/trace/tr_state.h b/src/gallium/drivers/trace/tr_state.h
index c1df63db6a..5ae533dc66 100644
--- a/src/gallium/drivers/trace/tr_state.h
+++ b/src/gallium/drivers/trace/tr_state.h
@@ -4,7 +4,7 @@
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
@@ -33,63 +33,44 @@
 #include "pipe/p_shader_tokens.h"
 
 
-void trace_dump_format(struct trace_stream *stream, 
-                       enum pipe_format format);
+void trace_dump_format(enum pipe_format format);
 
-void trace_dump_block(struct trace_stream *stream, 
-                      const struct pipe_format_block *block);
+void trace_dump_block(const struct pipe_format_block *block);
 
-void trace_dump_template(struct trace_stream *stream, 
-                         const struct pipe_texture *templat);
+void trace_dump_template(const struct pipe_texture *templat);
 
 
-void trace_dump_rasterizer_state(struct trace_stream *stream, 
-                                 const struct pipe_rasterizer_state *state);
+void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state);
 
-void trace_dump_poly_stipple(struct trace_stream *stream,
-                             const struct pipe_poly_stipple *state);
+void trace_dump_poly_stipple(const struct pipe_poly_stipple *state);
 
-void trace_dump_viewport_state(struct trace_stream *stream,
-                               const struct pipe_viewport_state *state);
+void trace_dump_viewport_state(const struct pipe_viewport_state *state);
 
-void trace_dump_scissor_state(struct trace_stream *stream,
-                              const struct pipe_scissor_state *state);
+void trace_dump_scissor_state(const struct pipe_scissor_state *state);
 
-void trace_dump_clip_state(struct trace_stream *stream,
-                           const struct pipe_clip_state *state);
+void trace_dump_clip_state(const struct pipe_clip_state *state);
 
-void trace_dump_constant_buffer(struct trace_stream *stream,
-                                const struct pipe_constant_buffer *state);
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state);
 
-void trace_dump_token(struct trace_stream *stream,
-                      const struct tgsi_token *token);
+void trace_dump_token(const struct tgsi_token *token);
 
-void trace_dump_shader_state(struct trace_stream *stream,
-                             const struct pipe_shader_state *state);
+void trace_dump_shader_state(const struct pipe_shader_state *state);
 
-void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
-                                          const struct pipe_depth_stencil_alpha_state *state);
+void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state);
 
-void trace_dump_blend_state(struct trace_stream *stream,
-                            const struct pipe_blend_state *state);
+void trace_dump_blend_state(const struct pipe_blend_state *state);
 
-void trace_dump_blend_color(struct trace_stream *stream,
-                            const struct pipe_blend_color *state);
+void trace_dump_blend_color(const struct pipe_blend_color *state);
 
-void trace_dump_framebuffer_state(struct trace_stream *stream,
-                                  const struct pipe_framebuffer_state *state);
+void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state);
 
-void trace_dump_sampler_state(struct trace_stream *stream,
-                              const struct pipe_sampler_state *state);
+void trace_dump_sampler_state(const struct pipe_sampler_state *state);
 
-void trace_dump_surface(struct trace_stream *stream,
-                        const struct pipe_surface *state);
+void trace_dump_surface(const struct pipe_surface *state);
 
-void trace_dump_vertex_buffer(struct trace_stream *stream,
-                              const struct pipe_vertex_buffer *state);
+void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state);
 
-void trace_dump_vertex_element(struct trace_stream *stream,
-                               const struct pipe_vertex_element *state);
+void trace_dump_vertex_element(const struct pipe_vertex_element *state);
 
 
 #endif /* TR_STATE_H */
diff --git a/src/gallium/drivers/trace/tr_stream.h b/src/gallium/drivers/trace/tr_stream.h
index d50fed2691..53e854aa91 100644
--- a/src/gallium/drivers/trace/tr_stream.h
+++ b/src/gallium/drivers/trace/tr_stream.h
@@ -4,7 +4,7 @@
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
@@ -28,6 +28,9 @@
 /**
  * @file
  * Cross-platform sequential access stream abstraction.
+ * 
+ * These are really general purpose file access functions, and might one day
+ * be moved into the util module.  
  */
 
 #ifndef TR_STREAM_H
diff --git a/src/gallium/drivers/trace/tr_winsys.c b/src/gallium/drivers/trace/tr_winsys.c
index 524049148d..be76c0716f 100644
--- a/src/gallium/drivers/trace/tr_winsys.c
+++ b/src/gallium/drivers/trace/tr_winsys.c
@@ -29,7 +29,6 @@
 #include "pipe/p_state.h"
 #include "util/u_hash_table.h"
 
-#include "tr_stream.h"
 #include "tr_dump.h"
 #include "tr_state.h"
 #include "tr_winsys.h"
@@ -51,19 +50,18 @@ static const char *
 trace_winsys_get_name(struct pipe_winsys *_winsys)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    const char *result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "get_name");
+   trace_dump_call_begin("pipe_winsys", "get_name");
    
-   trace_dump_arg(stream, ptr, winsys);
+   trace_dump_arg(ptr, winsys);
 
    result = winsys->get_name(winsys);
    
-   trace_dump_ret(stream, string, result);
+   trace_dump_ret(string, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -75,18 +73,17 @@ trace_winsys_flush_frontbuffer(struct pipe_winsys *_winsys,
                                void *context_private)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "flush_frontbuffer");
+   trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, surface);
-   trace_dump_arg(stream, ptr, context_private);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, surface);
+   trace_dump_arg(ptr, context_private);
 
    winsys->flush_frontbuffer(winsys, surface, context_private);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -94,19 +91,18 @@ static struct pipe_surface *
 trace_winsys_surface_alloc(struct pipe_winsys *_winsys)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    struct pipe_surface *result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc");
+   trace_dump_call_begin("pipe_winsys", "surface_alloc");
    
-   trace_dump_arg(stream, ptr, winsys);
+   trace_dump_arg(ptr, winsys);
 
    result = winsys->surface_alloc(winsys);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -121,19 +117,18 @@ trace_winsys_surface_alloc_storage(struct pipe_winsys *_winsys,
                                    unsigned tex_usage)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    int result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc_storage");
+   trace_dump_call_begin("pipe_winsys", "surface_alloc_storage");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, surface);
-   trace_dump_arg(stream, uint, width);
-   trace_dump_arg(stream, uint, height);
-   trace_dump_arg(stream, format, format);
-   trace_dump_arg(stream, uint, flags);
-   trace_dump_arg(stream, uint, tex_usage);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, surface);
+   trace_dump_arg(uint, width);
+   trace_dump_arg(uint, height);
+   trace_dump_arg(format, format);
+   trace_dump_arg(uint, flags);
+   trace_dump_arg(uint, tex_usage);
 
    result = winsys->surface_alloc_storage(winsys,
                                           surface,
@@ -142,9 +137,9 @@ trace_winsys_surface_alloc_storage(struct pipe_winsys *_winsys,
                                           flags,
                                           tex_usage);
    
-   trace_dump_ret(stream, int, result);
+   trace_dump_ret(int, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -155,18 +150,17 @@ trace_winsys_surface_release(struct pipe_winsys *_winsys,
                              struct pipe_surface **psurface)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    struct pipe_surface *surface = *psurface;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "surface_release");
+   trace_dump_call_begin("pipe_winsys", "surface_release");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, surface);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, surface);
 
    winsys->surface_release(winsys, psurface);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -177,22 +171,21 @@ trace_winsys_buffer_create(struct pipe_winsys *_winsys,
                            unsigned size)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    struct pipe_buffer *buffer;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "buffer_create");
+   trace_dump_call_begin("pipe_winsys", "buffer_create");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, uint, alignment);
-   trace_dump_arg(stream, uint, usage);
-   trace_dump_arg(stream, uint, size);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(uint, alignment);
+   trace_dump_arg(uint, usage);
+   trace_dump_arg(uint, size);
 
    buffer = winsys->buffer_create(winsys, alignment, usage, size);
    
-   trace_dump_ret(stream, ptr, buffer);
+   trace_dump_ret(ptr, buffer);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 
    /* Zero the buffer to avoid dumping uninitialized memory */
    if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
@@ -214,21 +207,20 @@ trace_winsys_user_buffer_create(struct pipe_winsys *_winsys,
                                 unsigned bytes)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    struct pipe_buffer *result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "user_buffer_create");
+   trace_dump_call_begin("pipe_winsys", "user_buffer_create");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, ptr);
-   trace_dump_arg(stream, uint, bytes);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, ptr);
+   trace_dump_arg(uint, bytes);
 
    result = winsys->user_buffer_create(winsys, ptr, bytes);
    
-   trace_dump_ret(stream, ptr, result);
+   trace_dump_ret(ptr, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -260,27 +252,26 @@ trace_winsys_buffer_unmap(struct pipe_winsys *_winsys,
                           struct pipe_buffer *buffer)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    const void *map;
    
    map = hash_table_get(tr_ws->buffer_maps, buffer);
    if(map) {
-      trace_dump_call_begin(stream, "pipe_winsys", "buffer_write");
+      trace_dump_call_begin("pipe_winsys", "buffer_write");
       
-      trace_dump_arg(stream, ptr, winsys);
+      trace_dump_arg(ptr, winsys);
       
-      trace_dump_arg(stream, ptr, buffer);
+      trace_dump_arg(ptr, buffer);
       
-      trace_dump_arg_begin(stream, "data");
-      trace_dump_bytes(stream, map, buffer->size);
-      trace_dump_arg_end(stream);
+      trace_dump_arg_begin("data");
+      trace_dump_bytes(map, buffer->size);
+      trace_dump_arg_end();
 
-      trace_dump_arg_begin(stream, "size");
-      trace_dump_uint(stream, buffer->size);
-      trace_dump_arg_end(stream);
+      trace_dump_arg_begin("size");
+      trace_dump_uint(buffer->size);
+      trace_dump_arg_end();
    
-      trace_dump_call_end(stream);
+      trace_dump_call_end();
 
       hash_table_remove(tr_ws->buffer_maps, buffer);
    }
@@ -294,17 +285,16 @@ trace_winsys_buffer_destroy(struct pipe_winsys *_winsys,
                             struct pipe_buffer *buffer)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "buffer_destroy");
+   trace_dump_call_begin("pipe_winsys", "buffer_destroy");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, buffer);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, buffer);
 
    winsys->buffer_destroy(winsys, buffer);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -314,19 +304,18 @@ trace_winsys_fence_reference(struct pipe_winsys *_winsys,
                              struct pipe_fence_handle *src)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    struct pipe_fence_handle *dst = *pdst;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "fence_reference");
+   trace_dump_call_begin("pipe_winsys", "fence_reference");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, dst);
-   trace_dump_arg(stream, ptr, src);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, dst);
+   trace_dump_arg(ptr, src);
 
    winsys->fence_reference(winsys, pdst, src);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
 }
 
 
@@ -336,21 +325,20 @@ trace_winsys_fence_signalled(struct pipe_winsys *_winsys,
                              unsigned flag)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    int result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "fence_signalled");
+   trace_dump_call_begin("pipe_winsys", "fence_signalled");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, fence);
-   trace_dump_arg(stream, uint, flag);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
 
    result = winsys->fence_signalled(winsys, fence, flag);
    
-   trace_dump_ret(stream, int, result);
+   trace_dump_ret(int, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -362,21 +350,20 @@ trace_winsys_fence_finish(struct pipe_winsys *_winsys,
                           unsigned flag)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    int result;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "fence_finish");
+   trace_dump_call_begin("pipe_winsys", "fence_finish");
    
-   trace_dump_arg(stream, ptr, winsys);
-   trace_dump_arg(stream, ptr, fence);
-   trace_dump_arg(stream, uint, flag);
+   trace_dump_arg(ptr, winsys);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
 
    result = winsys->fence_finish(winsys, fence, flag);
    
-   trace_dump_ret(stream, int, result);
+   trace_dump_ret(int, result);
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    return result;
 }
@@ -386,18 +373,17 @@ static void
 trace_winsys_destroy(struct pipe_winsys *_winsys)
 {
    struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct trace_stream *stream = tr_ws->stream;
    struct pipe_winsys *winsys = tr_ws->winsys;
    
-   trace_dump_call_begin(stream, "pipe_winsys", "destroy");
+   trace_dump_call_begin("pipe_winsys", "destroy");
    
-   trace_dump_arg(stream, ptr, winsys);
+   trace_dump_arg(ptr, winsys);
 
    /* 
    winsys->destroy(winsys); 
    */
    
-   trace_dump_call_end(stream);
+   trace_dump_call_end();
    
    hash_table_destroy(tr_ws->buffer_maps);
 
@@ -406,15 +392,16 @@ trace_winsys_destroy(struct pipe_winsys *_winsys)
 
 
 struct pipe_winsys *
-trace_winsys_create(struct trace_stream *stream, 
-                    struct pipe_winsys *winsys)
+trace_winsys_create(struct pipe_winsys *winsys)
 {
-   
    struct trace_winsys *tr_ws;
    
+   if(!winsys)
+      goto error1;
+   
    tr_ws = CALLOC_STRUCT(trace_winsys);
    if(!tr_ws)
-      return NULL;
+      goto error1;
 
    tr_ws->base.destroy = trace_winsys_destroy;
    tr_ws->base.get_name = trace_winsys_get_name;
@@ -432,16 +419,20 @@ trace_winsys_create(struct trace_stream *stream,
    tr_ws->base.fence_finish = trace_winsys_fence_finish;
    
    tr_ws->winsys = winsys;
-   tr_ws->stream = stream;
 
    tr_ws->buffer_maps = hash_table_create(trace_buffer_hash, 
                                           trace_buffer_compare);
    if(!tr_ws->buffer_maps)
-      return NULL;
+      goto error2;
    
-   trace_dump_call_begin(stream, "", "pipe_winsys_create");
-   trace_dump_ret(stream, ptr, winsys);
-   trace_dump_call_end(stream);
+   trace_dump_call_begin("", "pipe_winsys_create");
+   trace_dump_ret(ptr, winsys);
+   trace_dump_call_end();
 
    return &tr_ws->base;
+   
+error2:
+   FREE(tr_ws);
+error1:
+   return winsys;
 }
diff --git a/src/gallium/drivers/trace/tr_winsys.h b/src/gallium/drivers/trace/tr_winsys.h
index 704d2c57c8..2218117347 100644
--- a/src/gallium/drivers/trace/tr_winsys.h
+++ b/src/gallium/drivers/trace/tr_winsys.h
@@ -35,7 +35,6 @@
 
 
 struct hash_table;
-struct trace_stream;
 
 
 struct trace_winsys
@@ -44,8 +43,6 @@ struct trace_winsys
    
    struct pipe_winsys *winsys;
    
-   struct trace_stream *stream;
-   
    struct hash_table *buffer_maps;
 };
 
@@ -60,8 +57,7 @@ trace_winsys(struct pipe_winsys *winsys)
 
 
 struct pipe_winsys *
-trace_winsys_create(struct trace_stream *stream,
-                    struct pipe_winsys *winsys);
+trace_winsys_create(struct pipe_winsys *winsys);
 
 
 #endif /* TR_WINSYS_H_ */