Mercurial > libpst

comparison src/debug.c @ 202:2f38c4ce606f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
remove readpstlog, switch to plain ascii debug log files
author Carl Byington <carl@five-ten-sg.com>
date Mon, 18 May 2009 15:55:05 -0700
parents ac6e22c8a9cf
children 156cf548c764
comparison
equal deleted inserted replaced
201:3850a3b11745 202:2f38c4ce606f
1 #include "define.h" 1 #include "define.h"
2
3 struct pst_debug_item {
4 int type;
5 char * function;
6 unsigned int line;
7 char * file;
8 char * text;
9 struct pst_debug_item *next;
10 };
11
12 static struct pst_debug_item *item_head=NULL, *item_tail=NULL, *item_ptr=NULL, *info_ptr=NULL, *temp_list=NULL;
13 2
14 3
15 struct pst_debug_func { 4 struct pst_debug_func {
16 char * name; 5 char * name;
17 struct pst_debug_func *next; 6 struct pst_debug_func *next;
18 }; 7 };
19 8
20 static struct pst_debug_func *func_head=NULL, *func_ptr=NULL; 9
10 #define NUM_COL 32
11 #define MAX_DEPTH 32
12
13 static struct pst_debug_func *func_head = NULL;
14 static int func_depth = 0;
15 static char indent[MAX_DEPTH*4+1];
16 static FILE *debug_fp = NULL;
17 #ifdef HAVE_SEMAPHORE_H
18 static sem_t* debug_mutex = NULL;
19 #endif
21 20
22 21
23 static void pst_debug_write_msg(struct pst_debug_item *item, const char *fmt, va_list *ap, int size); 22 void pst_debug_lock()
24 static void pst_debug_write_hex(struct pst_debug_item *item, char *buf, size_t size, int col); 23 {
25 static void pst_debug_write(); 24 #ifdef HAVE_SEMAPHORE_H
26 25 if (debug_mutex) sem_wait(debug_mutex);
27 26 #endif
28 static size_t pst_debug_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
29 static size_t pst_debug_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream) {
30 return fwrite(ptr, size, nitems, stream);
31 } 27 }
32 28
33 29
34 // the largest text size we will store in memory. Otherwise we 30 void pst_debug_unlock()
35 // will do a debug_write, then create a new record, and write the 31 {
36 // text body directly to the file 32 #ifdef HAVE_SEMAPHORE_H
37 #define MAX_MESSAGE_SIZE 4096 33 if (debug_mutex) sem_post(debug_mutex);
38 34 #endif
39 void pst_debug(const char *fmt, ...) {
40 va_list ap;
41 va_start(ap,fmt);
42 vfprintf(stderr, fmt, ap);
43 va_end(ap);
44 } 35 }
45 36
46 37
47 #define NUM_COL 30 38 void pst_debug_init(const char* fname, void* output_mutex) {
48 void pst_debug_hexdumper(FILE *out, char *buf, size_t size, int col, int delta) { 39 #ifdef HAVE_SEMAPHORE_H
40 debug_mutex = (sem_t*)output_mutex;
41 #endif
42 memset(indent, ' ', MAX_DEPTH);
43 indent[MAX_DEPTH] = '\0';
44 if (debug_fp) pst_debug_close();
45 if (!fname) return;
46 if ((debug_fp = fopen(fname, "wb")) == NULL) {
47 fprintf(stderr, "Opening of file %s failed\n", fname);
48 exit(1);
49 }
50 }
51
52
53 void pst_debug_func(const char* function) {
54 struct pst_debug_func *func_ptr = pst_malloc (sizeof(struct pst_debug_func));
55 func_ptr->name = strdup(function);
56 func_ptr->next = func_head;
57 func_head = func_ptr;
58 func_depth++;
59 }
60
61
62 void pst_debug_func_ret() {
63 //remove the head item
64 struct pst_debug_func *func_ptr = func_head;
65 if (func_head) {
66 func_head = func_head->next;
67 free(func_ptr->name);
68 free(func_ptr);
69 func_depth--;
70 } else {
71 DIE(("function list is empty!\n"));
72 }
73 }
74
75
76 static void pst_debug_info(int line, const char* file);
77 static void pst_debug_info(int line, const char* file) {
78 int le = (func_depth > MAX_DEPTH) ? MAX_DEPTH : func_depth;
79 if (le > 0) le--;
80 char *func = (func_head ? func_head->name : "No Function");
81 pst_debug_lock();
82 fprintf(debug_fp, "%06d %.*s%s %s(%d) ", getpid(), le*4, indent, func, file, line);
83 }
84
85
86 void pst_debug(int line, const char* file, const char *fmt, ...) {
87 if (debug_fp) {
88 pst_debug_info(line, file);
89 va_list ap;
90 va_start(ap,fmt);
91 vfprintf(debug_fp, fmt, ap);
92 va_end(ap);
93 fflush(debug_fp);
94 pst_debug_unlock();
95 }
96 }
97
98
99 void pst_debug_hexdump(int line, const char *file, const char *buf, size_t size, int cols, int delta) {
100 if (debug_fp) {
101 pst_debug_info(line, file);
102 pst_debug_hexdumper(debug_fp, buf, size, cols, delta);
103 pst_debug_unlock();
104 }
105 }
106
107
108 void pst_debug_hexdumper(FILE *out, const char *buf, size_t size, int cols, int delta) {
109 int le = (func_depth > MAX_DEPTH) ? MAX_DEPTH : func_depth;
49 size_t off = 0, toff; 110 size_t off = 0, toff;
50 int count = 0; 111 int count = 0;
51 112
52 if (!out) return; // no file 113 if (!out) return; // no file
53 if (col == -1) col = NUM_COL; 114
115 if (cols == -1) cols = NUM_COL;
54 fprintf(out, "\n"); 116 fprintf(out, "\n");
55 while (off < size) { 117 while (off < size) {
56 fprintf(out, "%06"PRIx64"\t:", (int64_t)(off+delta)); 118 fprintf(out, "%06d %.*s%06"PRIx64"\t:", getpid(), le*4, indent, (int64_t)(off+delta));
57 toff = off; 119 toff = off;
58 while (count < col && off < size) { 120 while (count < cols && off < size) {
59 fprintf(out, "%02hhx ", (unsigned char)buf[off]); 121 fprintf(out, "%02hhx ", (unsigned char)buf[off]);
60 off++; count++; 122 off++; count++;
61 } 123 }
62 off = toff; 124 off = toff;
63 while (count < col) { 125 while (count < cols) {
64 // only happens at end of block to pad the text over to the text column 126 // only happens at end of block to pad the text over to the text column
65 fprintf(out, " "); 127 fprintf(out, " ");
66 count++; 128 count++;
67 } 129 }
68 count = 0; 130 count = 0;
69 fprintf(out, ":"); 131 fprintf(out, ":");
70 while (count < col && off < size) { 132 while (count < cols && off < size) {
71 fprintf(out, "%c", isgraph(buf[off])?buf[off]:'.'); 133 fprintf(out, "%c", isgraph(buf[off])?buf[off]:'.');
72 off++; count ++; 134 off++; count ++;
73 } 135 }
74 136
75 fprintf(out, "\n"); 137 fprintf(out, "\n");
76 count=0; 138 count=0;
77 } 139 }
78 140
79 fprintf(out, "\n"); 141 fprintf(out, "\n");
80 } 142 fflush(out);
81
82
83 static FILE *debug_fp = NULL;
84 static unsigned int max_items=DEBUG_MAX_ITEMS, curr_items=0;
85
86
87 void pst_debug_init(const char* fname) {
88 unsigned char version = DEBUG_VERSION;
89 item_head = item_tail = NULL;
90 curr_items = 0;
91 if (debug_fp) pst_debug_close();
92 if (!fname) return;
93 if ((debug_fp = fopen(fname, "wb")) == NULL) {
94 fprintf(stderr, "Opening of file %s failed\n", fname);
95 exit(1);
96 }
97 pst_debug_fwrite(&version, sizeof(char), 1, debug_fp);
98 }
99
100
101 // function must be called before pst_debug_msg. It sets up the
102 // structure for the function that follows
103 void pst_debug_msg_info(int line, const char* file, int type) {
104 char *x;
105 if (!debug_fp) return; // no file
106 info_ptr = (struct pst_debug_item*) pst_malloc(sizeof(struct pst_debug_item));
107 info_ptr->type = type;
108 info_ptr->line = line;
109 x = (func_head==NULL?"No Function":func_head->name);
110 info_ptr->function = (char*) pst_malloc(strlen(x)+1);
111 strcpy(info_ptr->function, x);
112
113 info_ptr->file = (char*) pst_malloc(strlen(file)+1);
114 strcpy(info_ptr->file, file);
115
116 //put the current record on a temp linked list
117 info_ptr->next = temp_list;
118 temp_list = info_ptr;
119 }
120
121
122 void pst_debug_msg_text(const char* fmt, ...) {
123 va_list ap;
124 int f, g;
125 char x[2];
126 #ifdef _WIN32
127 char *buf = NULL;
128 #endif
129 struct pst_debug_item *temp;
130 if (!debug_fp) return; // no file
131 // get the record off of the temp_list
132 info_ptr = temp_list;
133 if (info_ptr)
134 temp_list = info_ptr->next;
135 else {
136 fprintf(stderr, "NULL info_ptr. ERROR!!\n");
137 exit(-2);
138 }
139
140 #ifdef _WIN32
141 // vsnprintf trick doesn't work on msvc.
142 g = 2000;
143 f = -1;
144 while (f < 0) {
145 buf = realloc(buf, g+1);
146 va_start(ap, fmt);
147 f = vsnprintf(buf, g, fmt, ap);
148 va_end(ap);
149 g += g/2;
150 }
151 free(buf);
152 #else
153 // according to glibc 2.1, this should return the req. number of bytes for
154 // the string
155 va_start(ap, fmt);
156 f = vsnprintf(x, 1, fmt, ap);
157 va_end(ap);
158 #endif
159
160 if (f > 0 && f < MAX_MESSAGE_SIZE) {
161 info_ptr->text = (char*) pst_malloc(f+1);
162 va_start(ap, fmt);
163 if ((g = vsnprintf(info_ptr->text, f, fmt, ap)) == -1) {
164 fprintf(stderr, "_debug_msg: Dying! vsnprintf returned -1 for format \"%s\"\n", fmt);
165 exit(-2);
166 }
167 va_end(ap);
168 info_ptr->text[g] = '\0';
169 if (f != g) {
170 fprintf(stderr, "_debug_msg: f != g\n");
171 }
172 } else if (f > 0) { // it is over the max_message_size then
173 f += strlen(info_ptr->file)+strlen(info_ptr->function);
174 temp = info_ptr;
175 pst_debug_write(); // dump the current messages
176 info_ptr = temp;
177 va_start(ap, fmt);
178 pst_debug_write_msg(info_ptr, fmt, &ap, f);
179 va_end(ap);
180 free(info_ptr->function);
181 free(info_ptr->file);
182 free(info_ptr);
183 info_ptr = NULL;
184 return;
185 } else {
186 fprintf(stderr, "_debug_msg: error getting requested size of debug message\n");
187 info_ptr->text = "ERROR Saving\n";
188 }
189
190 // add to the linked list of pending items
191 if (!item_head) item_head = info_ptr;
192 info_ptr->next = NULL;
193 if (item_tail) item_tail->next = info_ptr;
194 item_tail = info_ptr;
195
196 if (++curr_items == max_items) {
197 // here we will jump off and save the contents
198 pst_debug_write();
199 info_ptr = NULL;
200 }
201 }
202
203
204 void pst_debug_hexdump(char *x, size_t y, int cols, int delta) {
205 struct pst_debug_item *temp;
206 if (!debug_fp) return; // no file
207 info_ptr = temp_list;
208 if (info_ptr) temp_list = info_ptr->next;
209 temp = info_ptr;
210 pst_debug_write();
211 info_ptr = temp;
212 pst_debug_write_hex(info_ptr, x, y, cols);
213 free(info_ptr->function);
214 free(info_ptr->file);
215 free(info_ptr);
216 info_ptr = NULL;
217 }
218
219
220 void pst_debug_func(const char *function) {
221 func_ptr = pst_malloc (sizeof(struct pst_debug_func));
222 func_ptr->name = pst_malloc(strlen(function)+1);
223 strcpy(func_ptr->name, function);
224 func_ptr->next = func_head;
225 func_head = func_ptr;
226 }
227
228
229 void pst_debug_func_ret() {
230 //remove the head item
231 func_ptr = func_head;
232 if (func_head) {
233 func_head = func_head->next;
234 free(func_ptr->name);
235 free(func_ptr);
236 } else {
237 DIE(("function list is empty!\n"));
238 }
239 } 143 }
240 144
241 145
242 void pst_debug_close(void) { 146 void pst_debug_close(void) {
243 pst_debug_write();
244 while (func_head) { 147 while (func_head) {
245 func_ptr = func_head; 148 struct pst_debug_func *func_ptr = func_head;
246 func_head = func_head->next; 149 func_head = func_head->next;
247 free(func_ptr->name); 150 free(func_ptr->name);
248 free(func_ptr); 151 free(func_ptr);
249 } 152 }
250 if (debug_fp) fclose(debug_fp); 153 if (debug_fp) fclose(debug_fp);
251 debug_fp = NULL; 154 debug_fp = NULL;
252 }
253
254
255 static void pst_debug_write() {
256 size_t size, ptr, funcname, filename, text, end;
257 char *buf = NULL, rec_type;
258 if (!debug_fp) return; // no file
259 int64_t index_pos = ftello(debug_fp);
260 int64_t file_pos = index_pos;
261 // add 2. One for the pointer to the next index,
262 // one for the count of this index
263 int index_size = ((curr_items+2) * sizeof(int64_t));
264 int64_t *index;
265 int index_ptr = 0;
266 struct pst_debug_file_rec_m mfile_rec;
267 struct pst_debug_file_rec_l lfile_rec;
268
269 if (curr_items == 0) return; // no items to write.
270
271 index = (int64_t*)pst_malloc(index_size);
272 memset(index, 0, index_size); // valgrind, avoid writing uninitialized data
273 file_pos += index_size;
274 // write the index first, we will re-write it later, but
275 // we want to allocate the space
276 pst_debug_fwrite(index, index_size, 1, debug_fp);
277 index[index_ptr++] = curr_items;
278
279 item_ptr = item_head;
280 while (item_ptr) {
281 file_pos = ftello(debug_fp);
282 index[index_ptr++] = file_pos;
283 size = strlen(item_ptr->function) +
284 strlen(item_ptr->file) +
285 strlen(item_ptr->text) + 3; //for the three \0s
286 if (buf) free(buf);
287 buf = pst_malloc(size+1);
288 ptr = 0;
289 funcname=ptr;
290 ptr += sprintf(&(buf[ptr]), "%s", item_ptr->function)+1;
291 filename=ptr;
292 ptr += sprintf(&(buf[ptr]), "%s", item_ptr->file)+1;
293 text=ptr;
294 ptr += sprintf(&(buf[ptr]), "%s", item_ptr->text)+1;
295 end=ptr;
296 if (end > USHRT_MAX) { // bigger than can be stored in a short
297 rec_type = 'L';
298 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
299 lfile_rec.type = item_ptr->type;
300 lfile_rec.line = item_ptr->line;
301 lfile_rec.funcname = funcname;
302 lfile_rec.filename = filename;
303 lfile_rec.text = text;
304 lfile_rec.end = end;
305 pst_debug_fwrite(&lfile_rec, sizeof(lfile_rec), 1, debug_fp);
306 } else {
307 rec_type = 'M';
308 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
309 mfile_rec.type = item_ptr->type;
310 mfile_rec.line = item_ptr->line;
311 mfile_rec.funcname = funcname;
312 mfile_rec.filename = filename;
313 mfile_rec.text = text;
314 mfile_rec.end = end;
315 pst_debug_fwrite(&mfile_rec, sizeof(mfile_rec), 1, debug_fp);
316 }
317 pst_debug_fwrite(buf, ptr, 1, debug_fp);
318 if (buf) free(buf); buf = NULL;
319 item_head = item_ptr->next;
320 free(item_ptr->function);
321 free(item_ptr->file);
322 free(item_ptr->text);
323 free(item_ptr);
324 item_ptr = item_head;
325 }
326 curr_items = 0;
327 index[index_ptr] = ftello(debug_fp);
328
329 // we should now have a complete index
330 fseeko(debug_fp, index_pos, SEEK_SET);
331 pst_debug_fwrite(index, index_size, 1, debug_fp);
332 fseeko(debug_fp, 0, SEEK_END);
333 item_ptr = item_head = item_tail = NULL;
334 free(index);
335 if (buf) free(buf);
336 }
337
338
339 static void pst_debug_write_msg(struct pst_debug_item *item, const char *fmt, va_list *ap, int size) {
340 struct pst_debug_file_rec_l lfile_rec;
341 struct pst_debug_file_rec_m mfile_rec;
342 unsigned char rec_type;
343 int index_size = 3 * sizeof(int64_t);
344 int64_t index[3];
345 int64_t index_pos, file_pos;
346 char zero = '\0';
347 unsigned int end;
348 if (!debug_fp) return; // no file
349 index[0] = 1; // only one item in this index
350 index[1] = 0; // valgrind, avoid writing uninitialized data
351 index[2] = 0; // ""
352 index_pos = ftello(debug_fp);
353 pst_debug_fwrite(index, index_size, 1, debug_fp);
354
355 index[1] = ftello(debug_fp);
356
357 if (size > USHRT_MAX) { // bigger than can be stored in a short
358 rec_type = 'L';
359 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
360 lfile_rec.type = item->type;
361 lfile_rec.line = item->line;
362 lfile_rec.funcname = 0;
363 lfile_rec.filename = strlen(item->function)+1;
364 lfile_rec.text = lfile_rec.filename+strlen(item->file)+1;
365 lfile_rec.end = 0; // valgrind, avoid writing uninitialized data
366 pst_debug_fwrite(&lfile_rec, sizeof(lfile_rec), 1, debug_fp);
367 } else {
368 rec_type = 'M';
369 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
370 mfile_rec.type = item->type;
371 mfile_rec.line = item->line;
372 mfile_rec.funcname = 0;
373 mfile_rec.filename = strlen(item->function)+1;
374 mfile_rec.text = mfile_rec.filename+strlen(item->file)+1;
375 mfile_rec.end = 0; // valgrind, avoid writing uninitialized data
376 pst_debug_fwrite(&mfile_rec, sizeof(mfile_rec), 1, debug_fp);
377 }
378 file_pos = ftello(debug_fp);
379 pst_debug_fwrite(item->function, strlen(item->function)+1, 1, debug_fp);
380 pst_debug_fwrite(item->file, strlen(item->file)+1, 1, debug_fp);
381 vfprintf(debug_fp, fmt, *ap);
382 pst_debug_fwrite(&zero, 1, 1, debug_fp);
383
384 end = (unsigned int) (ftello(debug_fp) - file_pos);
385
386 index[2] = ftello(debug_fp);
387 fseeko(debug_fp, index_pos, SEEK_SET);
388 pst_debug_fwrite(index, index_size, 1, debug_fp);
389 if (size > USHRT_MAX) {
390 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
391 lfile_rec.end = end;
392 pst_debug_fwrite(&lfile_rec, sizeof(lfile_rec), 1, debug_fp);
393 } else {
394 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
395 mfile_rec.end = end;
396 pst_debug_fwrite(&mfile_rec, sizeof(mfile_rec), 1, debug_fp);
397 }
398 fseeko(debug_fp, 0, SEEK_END);
399 }
400
401
402 void pst_debug_write_hex(struct pst_debug_item *item, char *buf, size_t size, int col) {
403 struct pst_debug_file_rec_l lfile_rec;
404 unsigned char rec_type;
405 int index_size = 3 * sizeof(int64_t);
406 int64_t index_pos, file_pos, index[3];
407 char zero='\0';
408 if (!debug_fp) return; // no file
409 index[0] = 1; // only one item in this index run
410 index[1] = 0; // valgrind, avoid writing uninitialized data
411 index[2] = 0; // ""
412 index_pos = ftello(debug_fp);
413 pst_debug_fwrite(index, index_size, 1, debug_fp);
414 index[1] = ftello(debug_fp);
415
416 // always use the long
417 rec_type = 'L';
418 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
419 lfile_rec.funcname = 0;
420 lfile_rec.filename = strlen(item->function)+1;
421 lfile_rec.text = lfile_rec.filename+strlen(item->file)+1;
422 lfile_rec.end = 0; // valgrind, avoid writing uninitialized data
423 lfile_rec.line = item->line;
424 lfile_rec.type = item->type;
425 pst_debug_fwrite(&lfile_rec, sizeof(lfile_rec), 1, debug_fp);
426
427 file_pos = ftello(debug_fp);
428 pst_debug_fwrite(item->function, strlen(item->function)+1, 1, debug_fp);
429 pst_debug_fwrite(item->file, strlen(item->file)+1, 1, debug_fp);
430
431 pst_debug_hexdumper(debug_fp, buf, size, col, 0);
432 pst_debug_fwrite(&zero, 1, 1, debug_fp);
433 lfile_rec.end = ftello(debug_fp) - file_pos;
434
435 index[2] = ftello(debug_fp);
436 fseeko(debug_fp, index_pos, SEEK_SET);
437 pst_debug_fwrite(index, index_size, 1, debug_fp);
438 pst_debug_fwrite(&rec_type, sizeof(char), 1, debug_fp);
439 pst_debug_fwrite(&lfile_rec, sizeof(lfile_rec), 1, debug_fp);
440 fseeko(debug_fp, 0, SEEK_END);
441 } 155 }
442 156
443 157
444 void *pst_malloc(size_t size) { 158 void *pst_malloc(size_t size) {
445 void *mem = malloc(size); 159 void *mem = malloc(size);