10 #define BT_BUF_SIZE 100
11 // booby trap (backtrace)
14 void *buffer[BT_BUF_SIZE];
15 int nptrs = backtrace(buffer, BT_BUF_SIZE);
16 char **trace = backtrace_symbols(buffer, nptrs);
18 for( int i=0; i<nptrs; ) printf("%s\n", trace[i++]);
23 BC_Trace *BC_Trace::global_trace = 0;
34 bc_trace_mutex execution_table;
35 bc_trace_mutex memory_table;
36 bc_trace_mutex lock_table;
37 bc_trace_list lock_free;
38 bc_trace_mutex file_table;
40 // incase lock set after task ends
41 static pthread_t last_lock_thread = 0;
42 static const char *last_lock_title = 0;
43 static const char *last_lock_location = 0;
45 trace_item::trace_item(bc_trace_t &t) : table(t) { ++table.size; }
46 trace_item::~trace_item() { --table.size; }
48 extern "C" void dump()
50 BC_Trace::dump_traces();
51 BC_Trace::dump_locks();
52 BC_Trace::dump_buffers();
55 #define TOTAL_TRACES 16
57 void BC_Trace::new_trace(const char *text)
59 if(!global_trace) return;
60 execution_table.lock();
62 if( execution_table.size >= TOTAL_TRACES ) {
63 it = (execution_item *)execution_table.first;
64 execution_table.remove_pointer(it);
67 it = new execution_item();
69 execution_table.append(it);
70 execution_table.unlock();
73 void BC_Trace::new_trace(const char *file, const char *function, int line)
75 char string[BCTEXTLEN];
76 snprintf(string, BCTEXTLEN, "%s: %s: %d", file, function, line);
80 void BC_Trace::delete_traces()
82 if(!global_trace) return;
83 execution_table.lock();
84 execution_table.clear();
85 execution_table.unlock();
88 void BC_Trace::enable_locks()
95 void BC_Trace::disable_locks()
99 while( lock_table.last ) {
100 lock_item *p = (lock_item*)lock_table.last;
102 lock_table.remove_pointer(p); lock_free.append(p);
108 // no canceling with lock held
109 void BC_Trace::lock_locks(const char *s)
112 last_lock_thread = pthread_self();
114 last_lock_location = 0;
117 void BC_Trace::unlock_locks()
122 #define TOTAL_LOCKS 256
124 int BC_Trace::set_lock(const char *title, const char *loc, trace_info *info)
126 if( !global_trace || !trace_locks ) return 0;
128 last_lock_thread = pthread_self();
129 last_lock_title = title;
130 last_lock_location = loc;
132 if( (it=(lock_item*)lock_free.first) != 0 )
133 lock_free.remove_pointer(it);
134 else if( lock_table.size >= TOTAL_LOCKS ) {
135 it = (lock_item*)lock_table.first;
136 lock_table.remove_pointer(it);
139 it = new lock_item();
140 it->set(info, title, loc);
141 lock_table.append(it);
142 info->trace = (void *)it;
147 void BC_Trace::set_lock2(int table_id, trace_info *info)
149 if( !global_trace || !trace_locks ) return;
151 lock_item *p = (lock_item *)info->trace;
152 if( !p || p->id != table_id ) {
153 p = (lock_item*)lock_table.last;
154 while( p && p->id != table_id ) p = (lock_item*)p->previous;
157 info->trace = (void *)p;
159 p->tid = pthread_self();
164 void BC_Trace::unset_lock2(int table_id, trace_info *info)
166 if( !global_trace || !trace_locks ) return;
168 lock_item *p = (lock_item *)info->trace;
169 if( !p || p->id != table_id ) {
170 p = (lock_item*)lock_table.last;
171 while( p && p->id != table_id ) p = (lock_item*)p->previous;
175 if( p ) { lock_table.remove_pointer(p); lock_free.append(p); }
179 void BC_Trace::unset_lock(trace_info *info)
181 if( !global_trace || !trace_locks ) return;
183 lock_item *p = (lock_item *)info->trace;
184 if( !p || p->info!=info || !p->is_owner ) {
185 p = (lock_item*)lock_table.last;
186 while( p && ( p->info!=info || !p->is_owner ) ) p = (lock_item*)p->previous;
190 if( p ) { lock_table.remove_pointer(p); lock_free.append(p); }
195 void BC_Trace::unset_all_locks(trace_info *info)
197 if( !global_trace || !trace_locks ) return;
199 lock_item *p = (lock_item*)lock_table.first;
201 lock_item *lp = p; p = (lock_item*)p->next;
202 if( lp->info != info ) continue;
203 lock_table.remove_pointer(lp); lock_free.append(lp);
208 void BC_Trace::clear_locks_tid(pthread_t tid)
210 if( !global_trace || !trace_locks ) return;
212 lock_item *p = (lock_item*)lock_table.first;
214 lock_item *lp = p; p = (lock_item*)p->next;
215 if( lp->tid != tid ) continue;
216 lock_table.remove_pointer(lp); lock_free.append(lp);
222 void BC_Trace::enable_memory()
227 void BC_Trace::disable_memory()
233 void BC_Trace::set_buffer(int size, void *ptr, const char* loc)
235 if(!global_trace) return;
236 if(!trace_memory) return;
238 //printf("BC_Trace::set_buffer %p %s\n", ptr, loc);
239 memory_table.append(new memory_item(size, ptr, loc));
240 memory_table.unlock();
243 int BC_Trace::unset_buffer(void *ptr)
245 if(!global_trace) return 0;
246 if(!trace_memory) return 0;
248 memory_item *p = (memory_item*)memory_table.first;
249 for( ; p!=0 && p->ptr!=ptr; p=(memory_item*)p->next );
251 memory_table.unlock();
257 void* operator new(size_t size)
259 void *result = malloc(size);
260 BUFFER(size, result, "new");
264 void* operator new[](size_t size)
266 void *result = malloc(size);
267 BUFFER(size, result, "new []");
271 void operator delete(void *ptr)
277 void operator delete[](void *ptr)
285 void BC_Trace::dump_traces(FILE *fp)
288 for( trace_item *tp=execution_table.first; tp!=0; tp=tp->next ) {
289 execution_item *p=(execution_item*)tp;
290 fprintf(fp," %s\n", (char*)p->value);
294 void BC_Trace::dump_locks(FILE *fp)
298 fprintf(fp,"signal_entry: lock table size=%d\n", lock_table.size);
299 for( trace_item *tp=lock_table.first; tp!=0; tp=tp->next ) {
300 lock_item *p=(lock_item*)tp;
301 fprintf(fp," %p %s %s %p%s\n", p->info, p->title,
302 p->loc, (void*)p->tid, p->is_owner ? " *" : "");
307 void BC_Trace::dump_buffers(FILE *fp)
312 fprintf(fp,"BC_Trace::dump_buffers: buffer table size=%d\n", memory_table.size);
313 for( trace_item *tp=memory_table.first; tp!=0; tp=tp->next ) {
314 memory_item *p=(memory_item*)tp;
315 fprintf(fp," %d %p %s\n", p->size, p->ptr, p->loc);
317 memory_table.unlock();
321 void BC_Trace::delete_temps()
324 if( file_table.size )
325 printf("BC_Trace::delete_temps: deleting %d temp files\n", file_table.size);
326 while( file_table.first ) {
327 file_item *p = (file_item*)file_table.first;
328 printf(" %s\n", p->value);
335 void BC_Trace::reset_locks()
340 void BC_Trace::set_temp(char *string)
343 file_item *it = new file_item();
345 file_table.append(it);
349 void BC_Trace::unset_temp(char *string)
352 file_item *p = (file_item *)file_table.last;
353 for( ; p!=0 && strcmp(p->value,string); p=(file_item*)p->previous );
361 TheLock TheLocker::the_lock;
362 TheList TheList::the_list;
364 int lock_item::table_id = 0;
366 void TheList::dbg_add(pthread_t tid, pthread_t owner, const char *nm)
368 TheLocker the_locker;
369 int i = the_list.size();
370 while( --i >= 0 && !(the_list[i]->tid == tid && the_list[i]->owner == owner) );
372 printf("dbg_add, dup %016lx %s %s\n",
373 (unsigned long)tid, nm, the_list[i]->name);
376 the_list.append(new TheDbg(tid, owner, nm));
379 void TheList::dbg_del(pthread_t tid)
381 TheLocker the_locker;
382 int i = the_list.size();
383 while( --i >= 0 && the_list[i]->tid != tid );
385 printf("dbg_del, mis %016lx\n",(unsigned long)tid);
388 the_list.remove_object_number(i);
392 void TheList::dump_threads(FILE *fp)
394 int i = the_list.size();
396 fprintf(fp, "thread 0x%012lx, owner 0x%012lx, %s\n",
397 (unsigned long)the_list[i]->tid, (unsigned long)the_list[i]->owner,
403 #define dbg_add(t, o, nm) do {} while(0)
404 #define dbg_del(t) do {} while(0)
405 void TheList::dump_threads(FILE *fp)
410 void BC_Trace::dump_threads(FILE *fp)
412 TheList::dump_threads(fp);
416 void BC_Trace::dump_shm_stat(const char *fn, FILE *fp)
418 char path[BCTEXTLEN];
419 sprintf(path, "/proc/sys/kernel/%s",fn);
420 FILE *sfp = fopen(path,"r");
423 fscanf(sfp, "%ju", &v);
425 fprintf(fp, "%s = %ju\n", fn, v);
428 void BC_Trace::dump_shm_stats(FILE *fp)
430 dump_shm_stat("shmall", fp);
431 dump_shm_stat("shmmax", fp);
432 dump_shm_stat("shmmni", fp);
433 FILE *sfp = fopen("/proc/sysvipc/shm","r");
435 char line[BCTEXTLEN];
437 if( !fgets(line,sizeof(line), sfp) ) return;
438 int64_t used = 0, other = 0;
439 int n_used = 0, n_other = 0;
440 while( fgets(line,sizeof(line), sfp) ) {
441 int key, shmid, perms, cpid, lpid, uid, gid, cuid, cgid;
442 int64_t size, nattch, atime, dtime, ctime, rss, swap;
444 "%d %d %o %ju %u %u %ju %u %u %u %u %ju %ju %ju %ju %ju",
445 &key, &shmid, &perms, &size, &cpid, &lpid, &nattch,
446 &uid, &gid, &cuid, &cgid, &atime, &dtime, &ctime,
447 &rss, &swap) != 16 ) break;
458 fprintf(fp, "shmused = %jd (%d items)\n", used, n_used);
459 fprintf(fp, "shmother = %jd (%d items)\n", other, n_other);