pipebuffer: split up assertion
[mesa-gbm:mesa.git] / src / gallium / auxiliary / pipebuffer / pb_bufmgr_debug.c
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 Jose Fonseca <jrfonseca@tungstengraphics.com>
33  */
34
35
36 #include "pipe/p_compiler.h"
37 #include "util/u_debug.h"
38 #include "os/os_thread.h"
39 #include "util/u_math.h"
40 #include "util/u_memory.h"
41 #include "util/u_double_list.h"
42 #include "util/u_time.h"
43 #include "util/u_debug_stack.h"
44
45 #include "pb_buffer.h"
46 #include "pb_bufmgr.h"
47
48
49 #ifdef DEBUG
50
51
52 #define PB_DEBUG_CREATE_BACKTRACE 8
53 #define PB_DEBUG_MAP_BACKTRACE 8
54
55
56 /**
57  * Convenience macro (type safe).
58  */
59 #define SUPER(__derived) (&(__derived)->base)
60
61
62 struct pb_debug_manager;
63
64
65 /**
66  * Wrapper around a pipe buffer which adds delayed destruction.
67  */
68 struct pb_debug_buffer
69 {
70    struct pb_buffer base;
71    
72    struct pb_buffer *buffer;
73    struct pb_debug_manager *mgr;
74    
75    pb_size underflow_size;
76    pb_size overflow_size;
77
78    struct debug_stack_frame create_backtrace[PB_DEBUG_CREATE_BACKTRACE];
79
80    pipe_mutex mutex;
81    unsigned map_count;
82    struct debug_stack_frame map_backtrace[PB_DEBUG_MAP_BACKTRACE];
83    
84    struct list_head head;
85 };
86
87
88 struct pb_debug_manager
89 {
90    struct pb_manager base;
91
92    struct pb_manager *provider;
93
94    pb_size underflow_size;
95    pb_size overflow_size;
96    
97    pipe_mutex mutex;
98    struct list_head list;
99 };
100
101
102 static INLINE struct pb_debug_buffer *
103 pb_debug_buffer(struct pb_buffer *buf)
104 {
105    assert(buf);
106    return (struct pb_debug_buffer *)buf;
107 }
108
109
110 static INLINE struct pb_debug_manager *
111 pb_debug_manager(struct pb_manager *mgr)
112 {
113    assert(mgr);
114    return (struct pb_debug_manager *)mgr;
115 }
116
117
118 static const uint8_t random_pattern[32] = {
119    0xaf, 0xcf, 0xa5, 0xa2, 0xc2, 0x63, 0x15, 0x1a, 
120    0x7e, 0xe2, 0x7e, 0x84, 0x15, 0x49, 0xa2, 0x1e,
121    0x49, 0x63, 0xf5, 0x52, 0x74, 0x66, 0x9e, 0xc4, 
122    0x6d, 0xcf, 0x2c, 0x4a, 0x74, 0xe6, 0xfd, 0x94
123 };
124
125
126 static INLINE void 
127 fill_random_pattern(uint8_t *dst, pb_size size)
128 {
129    pb_size i = 0;
130    while(size--) {
131       *dst++ = random_pattern[i++];
132       i &= sizeof(random_pattern) - 1;
133    }
134 }
135
136
137 static INLINE boolean 
138 check_random_pattern(const uint8_t *dst, pb_size size, 
139                      pb_size *min_ofs, pb_size *max_ofs) 
140 {
141    boolean result = TRUE;
142    pb_size i;
143    *min_ofs = size;
144    *max_ofs = 0;
145    for(i = 0; i < size; ++i) {
146       if(*dst++ != random_pattern[i % sizeof(random_pattern)]) {
147          *min_ofs = MIN2(*min_ofs, i);
148          *max_ofs = MAX2(*max_ofs, i);
149          result = FALSE;
150       }
151    }
152    return result;
153 }
154
155
156 static void
157 pb_debug_buffer_fill(struct pb_debug_buffer *buf)
158 {
159    uint8_t *map;
160    
161    map = pb_map(buf->buffer, PB_USAGE_CPU_WRITE, NULL);
162    assert(map);
163    if(map) {
164       fill_random_pattern(map, buf->underflow_size);
165       fill_random_pattern(map + buf->underflow_size + buf->base.size,
166                           buf->overflow_size);
167       pb_unmap(buf->buffer);
168    }
169 }
170
171
172 /**
173  * Check for under/over flows.
174  * 
175  * Should be called with the buffer unmaped.
176  */
177 static void
178 pb_debug_buffer_check(struct pb_debug_buffer *buf)
179 {
180    uint8_t *map;
181    
182    map = pb_map(buf->buffer,
183                 PB_USAGE_CPU_READ |
184                 PB_USAGE_UNSYNCHRONIZED, NULL);
185    assert(map);
186    if(map) {
187       boolean underflow, overflow;
188       pb_size min_ofs, max_ofs;
189       
190       underflow = !check_random_pattern(map, buf->underflow_size, 
191                                         &min_ofs, &max_ofs);
192       if(underflow) {
193          debug_printf("buffer underflow (offset -%u%s to -%u bytes) detected\n",
194                       buf->underflow_size - min_ofs,
195                       min_ofs == 0 ? "+" : "",
196                       buf->underflow_size - max_ofs);
197       }
198       
199       overflow = !check_random_pattern(map + buf->underflow_size + buf->base.size,
200                                        buf->overflow_size, 
201                                        &min_ofs, &max_ofs);
202       if(overflow) {
203          debug_printf("buffer overflow (size %u plus offset %u to %u%s bytes) detected\n",
204                       buf->base.size,
205                       min_ofs,
206                       max_ofs,
207                       max_ofs == buf->overflow_size - 1 ? "+" : "");
208       }
209       
210       if(underflow || overflow)
211          debug_backtrace_dump(buf->create_backtrace, PB_DEBUG_CREATE_BACKTRACE);
212
213       debug_assert(!underflow);
214       debug_assert(!overflow);
215
216       /* re-fill if not aborted */
217       if(underflow)
218          fill_random_pattern(map, buf->underflow_size);
219       if(overflow)
220          fill_random_pattern(map + buf->underflow_size + buf->base.size,
221                              buf->overflow_size);
222
223       pb_unmap(buf->buffer);
224    }
225 }
226
227
228 static void
229 pb_debug_buffer_destroy(struct pb_buffer *_buf)
230 {
231    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
232    struct pb_debug_manager *mgr = buf->mgr;
233    
234    assert(!pipe_is_referenced(&buf->base.reference));
235    
236    pb_debug_buffer_check(buf);
237
238    pipe_mutex_lock(mgr->mutex);
239    LIST_DEL(&buf->head);
240    pipe_mutex_unlock(mgr->mutex);
241
242    pipe_mutex_destroy(buf->mutex);
243    
244    pb_reference(&buf->buffer, NULL);
245    FREE(buf);
246 }
247
248
249 static void *
250 pb_debug_buffer_map(struct pb_buffer *_buf, 
251                     unsigned flags, void *flush_ctx)
252 {
253    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
254    void *map;
255    
256    pb_debug_buffer_check(buf);
257
258    map = pb_map(buf->buffer, flags, flush_ctx);
259    if(!map)
260       return NULL;
261    
262    if(map) {
263       pipe_mutex_lock(buf->mutex);
264       ++buf->map_count;
265       debug_backtrace_capture(buf->map_backtrace, 1, PB_DEBUG_MAP_BACKTRACE);
266       pipe_mutex_unlock(buf->mutex);
267    }
268    
269    return (uint8_t *)map + buf->underflow_size;
270 }
271
272
273 static void
274 pb_debug_buffer_unmap(struct pb_buffer *_buf)
275 {
276    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);   
277    
278    pipe_mutex_lock(buf->mutex);
279    assert(buf->map_count);
280    if(buf->map_count)
281       --buf->map_count;
282    pipe_mutex_unlock(buf->mutex);
283    
284    pb_unmap(buf->buffer);
285    
286    pb_debug_buffer_check(buf);
287 }
288
289
290 static void
291 pb_debug_buffer_get_base_buffer(struct pb_buffer *_buf,
292                                 struct pb_buffer **base_buf,
293                                 pb_size *offset)
294 {
295    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
296    pb_get_base_buffer(buf->buffer, base_buf, offset);
297    *offset += buf->underflow_size;
298 }
299
300
301 static enum pipe_error 
302 pb_debug_buffer_validate(struct pb_buffer *_buf, 
303                          struct pb_validate *vl,
304                          unsigned flags)
305 {
306    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
307    
308    pipe_mutex_lock(buf->mutex);
309    if(buf->map_count) {
310       debug_printf("%s: attempting to validate a mapped buffer\n", __FUNCTION__);
311       debug_printf("last map backtrace is\n");
312       debug_backtrace_dump(buf->map_backtrace, PB_DEBUG_MAP_BACKTRACE);
313    }
314    pipe_mutex_unlock(buf->mutex);
315
316    pb_debug_buffer_check(buf);
317
318    return pb_validate(buf->buffer, vl, flags);
319 }
320
321
322 static void
323 pb_debug_buffer_fence(struct pb_buffer *_buf, 
324                       struct pipe_fence_handle *fence)
325 {
326    struct pb_debug_buffer *buf = pb_debug_buffer(_buf);
327    pb_fence(buf->buffer, fence);
328 }
329
330
331 const struct pb_vtbl 
332 pb_debug_buffer_vtbl = {
333       pb_debug_buffer_destroy,
334       pb_debug_buffer_map,
335       pb_debug_buffer_unmap,
336       pb_debug_buffer_validate,
337       pb_debug_buffer_fence,
338       pb_debug_buffer_get_base_buffer
339 };
340
341
342 static void
343 pb_debug_manager_dump_locked(struct pb_debug_manager *mgr)
344 {
345    struct list_head *curr, *next;
346    struct pb_debug_buffer *buf;
347
348    curr = mgr->list.next;
349    next = curr->next;
350    while(curr != &mgr->list) {
351       buf = LIST_ENTRY(struct pb_debug_buffer, curr, head);
352
353       debug_printf("buffer = %p\n", (void *) buf);
354       debug_printf("    .size = 0x%x\n", buf->base.size);
355       debug_backtrace_dump(buf->create_backtrace, PB_DEBUG_CREATE_BACKTRACE);
356       
357       curr = next; 
358       next = curr->next;
359    }
360
361 }
362
363
364 static struct pb_buffer *
365 pb_debug_manager_create_buffer(struct pb_manager *_mgr, 
366                                pb_size size,
367                                const struct pb_desc *desc)
368 {
369    struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
370    struct pb_debug_buffer *buf;
371    struct pb_desc real_desc;
372    pb_size real_size;
373    
374    assert(size);
375    assert(desc->alignment);
376
377    buf = CALLOC_STRUCT(pb_debug_buffer);
378    if(!buf)
379       return NULL;
380    
381    real_size = mgr->underflow_size + size + mgr->overflow_size;
382    real_desc = *desc;
383    real_desc.usage |= PB_USAGE_CPU_WRITE;
384    real_desc.usage |= PB_USAGE_CPU_READ;
385
386    buf->buffer = mgr->provider->create_buffer(mgr->provider, 
387                                               real_size, 
388                                               &real_desc);
389    if(!buf->buffer) {
390       FREE(buf);
391 #if 0
392       pipe_mutex_lock(mgr->mutex);
393       debug_printf("%s: failed to create buffer\n", __FUNCTION__);
394       if(!LIST_IS_EMPTY(&mgr->list))
395          pb_debug_manager_dump_locked(mgr);
396       pipe_mutex_unlock(mgr->mutex);
397 #endif
398       return NULL;
399    }
400    
401    assert(pipe_is_referenced(&buf->buffer->reference));
402    assert(pb_check_alignment(real_desc.alignment, buf->buffer->alignment));
403    assert(pb_check_usage(real_desc.usage, buf->buffer->usage));
404    assert(buf->buffer->size >= real_size);
405    
406    pipe_reference_init(&buf->base.reference, 1);
407    buf->base.alignment = desc->alignment;
408    buf->base.usage = desc->usage;
409    buf->base.size = size;
410    
411    buf->base.vtbl = &pb_debug_buffer_vtbl;
412    buf->mgr = mgr;
413
414    buf->underflow_size = mgr->underflow_size;
415    buf->overflow_size = buf->buffer->size - buf->underflow_size - size;
416    
417    debug_backtrace_capture(buf->create_backtrace, 1, PB_DEBUG_CREATE_BACKTRACE);
418
419    pb_debug_buffer_fill(buf);
420    
421    pipe_mutex_init(buf->mutex);
422    
423    pipe_mutex_lock(mgr->mutex);
424    LIST_ADDTAIL(&buf->head, &mgr->list);
425    pipe_mutex_unlock(mgr->mutex);
426
427    return &buf->base;
428 }
429
430
431 static void
432 pb_debug_manager_flush(struct pb_manager *_mgr)
433 {
434    struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
435    assert(mgr->provider->flush);
436    if(mgr->provider->flush)
437       mgr->provider->flush(mgr->provider);
438 }
439
440
441 static void
442 pb_debug_manager_destroy(struct pb_manager *_mgr)
443 {
444    struct pb_debug_manager *mgr = pb_debug_manager(_mgr);
445    
446    pipe_mutex_lock(mgr->mutex);
447    if(!LIST_IS_EMPTY(&mgr->list)) {
448       debug_printf("%s: unfreed buffers\n", __FUNCTION__);
449       pb_debug_manager_dump_locked(mgr);
450    }
451    pipe_mutex_unlock(mgr->mutex);
452    
453    pipe_mutex_destroy(mgr->mutex);
454    mgr->provider->destroy(mgr->provider);
455    FREE(mgr);
456 }
457
458
459 struct pb_manager *
460 pb_debug_manager_create(struct pb_manager *provider, 
461                         pb_size underflow_size, pb_size overflow_size) 
462 {
463    struct pb_debug_manager *mgr;
464
465    if(!provider)
466       return NULL;
467    
468    mgr = CALLOC_STRUCT(pb_debug_manager);
469    if (!mgr)
470       return NULL;
471
472    mgr->base.destroy = pb_debug_manager_destroy;
473    mgr->base.create_buffer = pb_debug_manager_create_buffer;
474    mgr->base.flush = pb_debug_manager_flush;
475    mgr->provider = provider;
476    mgr->underflow_size = underflow_size;
477    mgr->overflow_size = overflow_size;
478     
479    pipe_mutex_init(mgr->mutex);
480    LIST_INITHEAD(&mgr->list);
481
482    return &mgr->base;
483 }
484
485
486 #else /* !DEBUG */
487
488
489 struct pb_manager *
490 pb_debug_manager_create(struct pb_manager *provider, 
491                         pb_size underflow_size, pb_size overflow_size) 
492 {
493    return provider;
494 }
495
496
497 #endif /* !DEBUG */