1 /**************************************************************************
2 *
3 * Copyright 2010 Luca Barbieri
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 **************************************************************************/
26
27 #if defined(DEBUG)
28
29 /**
30 * If the GALLIUM_REFCNT_LOG env var is defined as a filename, gallium
31 * reference counting will be logged to the file.
32 *
33 * See http://www-archive.mozilla.org/performance/refcnt-balancer.html
34 * for what to do with the output on Linux, use tools/addr2line.sh to
35 * postprocess it before anything else.
36 */
37
38 #include <stdio.h>
39
40 #include "util/u_debug.h"
41 #include "util/u_debug_refcnt.h"
42 #include "util/u_debug_stack.h"
43 #include "util/u_debug_symbol.h"
44 #include "util/u_string.h"
45 #include "util/u_hash_table.h"
46 #include "os/os_thread.h"
47
48 int debug_refcnt_state;
49
50 static FILE *stream;
51
52 /* TODO: maybe move this serial machinery to a stand-alone module and
53 * expose it?
54 */
55 pipe_static_mutex(serials_mutex);
56
57 static struct util_hash_table *serials_hash;
58 static unsigned serials_last;
59
60
61 static unsigned
hash_ptr(void * p)62 hash_ptr(void *p)
63 {
64 return (unsigned) (uintptr_t) p;
65 }
66
67
68 static int
compare_ptr(void * a,void * b)69 compare_ptr(void *a, void *b)
70 {
71 if (a == b)
72 return 0;
73 else if (a < b)
74 return -1;
75 else
76 return 1;
77 }
78
79
80 /**
81 * Return a small integer serial number for the given pointer.
82 */
83 static boolean
debug_serial(void * p,unsigned * pserial)84 debug_serial(void *p, unsigned *pserial)
85 {
86 unsigned serial;
87 boolean found = TRUE;
88 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
89 static boolean first = TRUE;
90
91 if (first) {
92 pipe_mutex_init(serials_mutex);
93 first = FALSE;
94 }
95 #endif
96
97 pipe_mutex_lock(serials_mutex);
98 if (!serials_hash)
99 serials_hash = util_hash_table_create(hash_ptr, compare_ptr);
100
101 serial = (unsigned) (uintptr_t) util_hash_table_get(serials_hash, p);
102 if (!serial) {
103 /* time to stop logging... (you'll have a 100 GB logfile at least at
104 * this point) TODO: avoid this
105 */
106 serial = ++serials_last;
107 if (!serial) {
108 debug_error("More than 2^32 objects detected, aborting.\n");
109 os_abort();
110 }
111
112 util_hash_table_set(serials_hash, p, (void *) (uintptr_t) serial);
113 found = FALSE;
114 }
115 pipe_mutex_unlock(serials_mutex);
116
117 *pserial = serial;
118
119 return found;
120 }
121
122
123 /**
124 * Free the serial number for the given pointer.
125 */
126 static void
debug_serial_delete(void * p)127 debug_serial_delete(void *p)
128 {
129 pipe_mutex_lock(serials_mutex);
130 util_hash_table_remove(serials_hash, p);
131 pipe_mutex_unlock(serials_mutex);
132 }
133
134
135 #define STACK_LEN 64
136
137 static void
dump_stack(const char * symbols[STACK_LEN])138 dump_stack(const char *symbols[STACK_LEN])
139 {
140 unsigned i;
141 for (i = 0; i < STACK_LEN; ++i) {
142 if (symbols[i])
143 fprintf(stream, "%s\n", symbols[i]);
144 }
145 fprintf(stream, "\n");
146 }
147
148
149 /**
150 * Log a reference count change to the log file (if enabled).
151 * This is called via the pipe_reference() and debug_reference() functions,
152 * basically whenever a reference count is initialized or changed.
153 *
154 * \param p the refcount being changed (the value is not changed here)
155 * \param get_desc a function which will be called to print an object's
156 * name/pointer into a string buffer during logging
157 * \param change the reference count change which must be +/-1 or 0 when
158 * creating the object and initializing the refcount.
159 */
160 void
debug_reference_slowpath(const struct pipe_reference * p,debug_reference_descriptor get_desc,int change)161 debug_reference_slowpath(const struct pipe_reference *p,
162 debug_reference_descriptor get_desc, int change)
163 {
164 assert(change >= -1);
165 assert(change <= 1);
166
167 if (debug_refcnt_state < 0)
168 return;
169
170 if (!debug_refcnt_state) {
171 const char *filename = debug_get_option("GALLIUM_REFCNT_LOG", NULL);
172 if (filename && filename[0])
173 stream = fopen(filename, "wt");
174
175 if (stream)
176 debug_refcnt_state = 1;
177 else
178 debug_refcnt_state = -1;
179 }
180
181 if (debug_refcnt_state > 0) {
182 struct debug_stack_frame frames[STACK_LEN];
183 const char *symbols[STACK_LEN];
184 char buf[1024];
185 unsigned i;
186 unsigned refcnt = p->count;
187 unsigned serial;
188 boolean existing = debug_serial((void *) p, &serial);
189
190 debug_backtrace_capture(frames, 1, STACK_LEN);
191 for (i = 0; i < STACK_LEN; ++i) {
192 if (frames[i].function)
193 symbols[i] = debug_symbol_name_cached(frames[i].function);
194 else
195 symbols[i] = 0;
196 }
197
198 get_desc(buf, p);
199
200 if (!existing) {
201 fprintf(stream, "<%s> %p %u Create\n", buf, (void *) p, serial);
202 dump_stack(symbols);
203
204 /* this is here to provide a gradual change even if we don't see
205 * the initialization
206 */
207 for (i = 1; i <= refcnt - change; ++i) {
208 fprintf(stream, "<%s> %p %u AddRef %u\n", buf, (void *) p,
209 serial, i);
210 dump_stack(symbols);
211 }
212 }
213
214 if (change) {
215 fprintf(stream, "<%s> %p %u %s %u\n", buf, (void *) p, serial,
216 change > 0 ? "AddRef" : "Release", refcnt);
217 dump_stack(symbols);
218 }
219
220 if (!refcnt) {
221 debug_serial_delete((void *) p);
222 fprintf(stream, "<%s> %p %u Destroy\n", buf, (void *) p, serial);
223 dump_stack(symbols);
224 }
225
226 fflush(stream);
227 }
228 }
229
230 #endif /* DEBUG */
231