pb_bufmgr_debug.c revision c46c07f6c60edb60514756bd6af7918f70931e53 
1/**************************************************************************
2 *
3 * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28/**
29 * \file
30 * Debug buffer manager to detect buffer under- and overflows.
31 *
32 * \author José Fonseca <jrfonseca@tungstengraphics.com>
33 */
34
35
36#include "pipe/p_compiler.h"
37#include "pipe/p_debug.h"
38#include "pipe/p_winsys.h"
39#include "pipe/p_thread.h"
40#include "util/u_math.h"
41#include "util/u_memory.h"
42#include "util/u_double_list.h"
43#include "util/u_time.h"
44
45#include "pb_buffer.h"
46#include "pb_bufmgr.h"
47
48
49#ifdef DEBUG
50
51
52/**
53 * Convenience macro (type safe).
54 */
55#define SUPER(__derived) (&(__derived)->base)
56
57
58struct pb_debug_manager;
59
60
61/**
62 * Wrapper around a pipe buffer which adds delayed destruction.
63 */
64struct pb_debug_buffer
65{
66   struct pb_buffer base;
67
68   struct pb_buffer *buffer;
69   struct pb_debug_manager *mgr;
70
71   size_t underflow_size;
72   size_t overflow_size;
73};
74
75
76struct pb_debug_manager
77{
78   struct pb_manager base;
79
80   struct pb_manager *provider;
81
82   size_t band_size;
83};
84
85
86static INLINE struct pb_debug_buffer *
87pb_debug_buffer(struct pb_buffer *buf)
88{
89   assert(buf);
90   return (struct pb_debug_buffer *)buf;
91}
92
93
94static INLINE struct pb_debug_manager *
95pb_debug_manager(struct pb_manager *mgr)
96{
97   assert(mgr);
98   return (struct pb_debug_manager *)mgr;
99}
100
101
102static const uint8_t random_pattern[32] = {
103   0xaf, 0xcf, 0xa5, 0xa2, 0xc2, 0x63, 0x15, 0x1a,
104   0x7e, 0xe2, 0x7e, 0x84, 0x15, 0x49, 0xa2, 0x1e,
105   0x49, 0x63, 0xf5, 0x52, 0x74, 0x66, 0x9e, 0xc4,
106   0x6d, 0xcf, 0x2c, 0x4a, 0x74, 0xe6, 0xfd, 0x94
107};
108
109
110static INLINE void
111fill_random_pattern(uint8_t *dst, size_t size)
112{
113   size_t i = 0;
114   while(size--) {
115      *dst++ = random_pattern[i++];
116      i &= sizeof(random_pattern) - 1;
117   }
118}
119
120
121static INLINE boolean
122check_random_pattern(const uint8_t *dst, size_t size,
123                     size_t *min_ofs, size_t *max_ofs)
124{
125   boolean result = TRUE;
126   size_t i;
127   *min_ofs = size;
128   *max_ofs = 0;
129   for(i = 0; i < size; ++i) {
130      if(*dst++ != random_pattern[i % sizeof(random_pattern)]) {
131         *min_ofs = MIN2(*min_ofs, i);
132         *max_ofs = MAX2(*max_ofs, i);
133	 result = FALSE;
134      }
135   }
136   return result;
137}
138
139
140static void
141pb_debug_buffer_fill(struct pb_debug_buffer *buf)
142{
143   uint8_t *map;
144
145   map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
146   assert(map);
147   if(map) {
148      fill_random_pattern(map, buf->underflow_size);
149      fill_random_pattern(map + buf->underflow_size + buf->base.base.size,
150                          buf->overflow_size);
151      pb_unmap(buf->buffer);
152   }
153}
154
155
156/**
157 * Check for under/over flows.
158 *
159 * Should be called with the buffer unmaped.
160 */
161static void
162pb_debug_buffer_check(struct pb_debug_buffer *buf)
163{
164   uint8_t *map;
165
166   map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_CPU_READ);
167   assert(map);
168   if(map) {
169      boolean underflow, overflow;
170      size_t min_ofs, max_ofs;
171
172      underflow = !check_random_pattern(map, buf->underflow_size,
173                                        &min_ofs, &max_ofs);
174      if(underflow) {
175         debug_printf("buffer underflow (offset -%u%s to -%u bytes) detected\n",
176                      buf->underflow_size - min_ofs,
177                      min_ofs == 0 ? "+" : "",
178                      buf->underflow_size - max_ofs);
179      }
180
181      overflow = !check_random_pattern(map + buf->underflow_size + buf->base.base.size,
182                                       buf->overflow_size,
183                                       &min_ofs, &max_ofs);
184      if(overflow) {
185         debug_printf("buffer overflow (size %u plus offset %u to %u%s bytes) detected\n",
186                      buf->base.base.size,
187                      min_ofs,
188                      max_ofs,
189                      max_ofs == buf->overflow_size - 1 ? "+" : "");
190      }
191
192      debug_assert(!underflow && !overflow);
193
194      /* re-fill if not aborted */
195      if(underflow)
196         fill_random_pattern(map, buf->underflow_size);
197      if(overflow)
198         fill_random_pattern(map + buf->underflow_size + buf->base.base.size,
199                             buf->overflow_size);
200
201      pb_unmap(buf->buffer);
202   }
203}
204
205
206static void
207pb_debug_buffer_destroy(struct pb_buffer *_buf)
208{
209   struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
210
211   assert(!buf->base.base.refcount);
212
213   pb_debug_buffer_check(buf);
214
215   pb_reference(&buf->buffer, NULL);
216   FREE(buf);
217}
218
219
220static void *
221pb_debug_buffer_map(struct pb_buffer *_buf,
222                    unsigned flags)
223{
224   struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
225   void *map;
226
227   pb_debug_buffer_check(buf);
228
229   map = pb_map(buf->buffer, flags);
230   if(!map)
231      return NULL;
232
233   return (uint8_t *)map + buf->underflow_size;
234}
235
236
237static void
238pb_debug_buffer_unmap(struct pb_buffer *_buf)
239{
240   struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
241   pb_unmap(buf->buffer);
242
243   pb_debug_buffer_check(buf);
244}
245
246
247static void
248pb_debug_buffer_get_base_buffer(struct pb_buffer *_buf,
249                                struct pb_buffer **base_buf,
250                                unsigned *offset)
251{
252   struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
253   pb_get_base_buffer(buf->buffer, base_buf, offset);
254   *offset += buf->underflow_size;
255}
256
257
258const struct pb_vtbl
259pb_debug_buffer_vtbl = {
260      pb_debug_buffer_destroy,
261      pb_debug_buffer_map,
262      pb_debug_buffer_unmap,
263      pb_debug_buffer_get_base_buffer
264};
265
266
267static struct pb_buffer *
268pb_debug_manager_create_buffer(struct pb_manager *_mgr,
269                               size_t size,
270                               const struct pb_desc *desc)
271{
272   struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
273   struct pb_debug_buffer *buf;
274   struct pb_desc real_desc;
275   size_t real_size;
276
277   buf = CALLOC_STRUCT(pb_debug_buffer);
278   if(!buf)
279      return NULL;
280
281   real_size = size + 2*mgr->band_size;
282   real_desc = *desc;
283   real_desc.usage |= PIPE_BUFFER_USAGE_CPU_WRITE;
284   real_desc.usage |= PIPE_BUFFER_USAGE_CPU_READ;
285
286   buf->buffer = mgr->provider->create_buffer(mgr->provider,
287                                              real_size,
288                                              &real_desc);
289   if(!buf->buffer) {
290      FREE(buf);
291      return NULL;
292   }
293
294   assert(buf->buffer->base.refcount >= 1);
295   assert(pb_check_alignment(real_desc.alignment, buf->buffer->base.alignment));
296   assert(pb_check_usage(real_desc.usage, buf->buffer->base.usage));
297   assert(buf->buffer->base.size >= real_size);
298
299   buf->base.base.refcount = 1;
300   buf->base.base.alignment = desc->alignment;
301   buf->base.base.usage = desc->usage;
302   buf->base.base.size = size;
303
304   buf->base.vtbl = &pb_debug_buffer_vtbl;
305   buf->mgr = mgr;
306
307   buf->underflow_size = mgr->band_size;
308   buf->overflow_size = buf->buffer->base.size - buf->underflow_size - size;
309
310   pb_debug_buffer_fill(buf);
311
312   return &buf->base;
313}
314
315
316static void
317pb_debug_manager_destroy(struct pb_manager *_mgr)
318{
319   struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
320   mgr->provider->destroy(mgr->provider);
321   FREE(mgr);
322}
323
324
325struct pb_manager *
326pb_debug_manager_create(struct pb_manager *provider, size_t band_size)
327{
328   struct pb_debug_manager *mgr;
329
330   if(!provider)
331      return NULL;
332
333   mgr = CALLOC_STRUCT(pb_debug_manager);
334   if (!mgr)
335      return NULL;
336
337   mgr->base.destroy = pb_debug_manager_destroy;
338   mgr->base.create_buffer = pb_debug_manager_create_buffer;
339   mgr->provider = provider;
340   mgr->band_size = band_size;
341
342   return &mgr->base;
343}
344
345
346#else /* !DEBUG */
347
348
349struct pb_manager *
350pb_debug_manager_create(struct pb_manager *provider, size_t band_size)
351{
352   return provider;
353}
354
355
356#endif /* !DEBUG */
357