一个简单的 console logger 和 stack tracer

wolf0403

一个简单的 stack trace 例程，C/C++ 两套接口
debug.h，前半是 C 接口，后半是 C++ 接口

1. #ifndef DEBUG_H
   
2. #define DEBUG_H
   
3. 
   
4. #include <unistd.h>
   
5. #include <pthread.h>
   
6. #include <stdlib.h>
   
7. #include <stdio.h>
   
8. #include <stdarg.h>
   
9. #include <assert.h>
   
10. 
    
11. #ifdef __cplusplus
    
12. extern "C" {
    
13. #endif
    
14. 
    
15.   // Will enable seperate output for each thread, set default level to EMERG
    
16.   int dbg_enable ();
    
17. 
    
18.   // Logging output control level. EMERG can't be hided. GETVAL retrieves current value without changing.
    
19.   typedef enum {GETVAL = -1, EMERG = 0, ERROR, WARNING, INFO, DEBUG, NUM_LEVELS} dbg_level_t;
    
20. 
    
21.   dbg_level_t dbg_level ( dbg_level_t newlvl );
    
22. 
    
23.   // Setting prefix / postfix for each message.
    
24.   void dbg_set_decorate ( char *dec[NUM_LEVELS * 2] );
    
25. 
    
26.   // Output function.
    
27.   int dbg_printf ( dbg_level_t lvl, const char *fmt, ... );
    
28. 
    
29.   // Print stack point info with current thread's output.
    
30.   int dbg_dump_stacktrace ();
    
31. 
    
32.   void __dbg_enter (const char *file, const char *func, int line);
    
33. 
    
34.   // Setting / cancelling stack point. C++ should use DECLARE_TRACEPOINT() macro
    
35.   #define dbg_enter() do { __dbg_enter(__FILE__,__FUNCTION__,__LINE__); } while(0)
    
36.   void dbg_leave ();
    
37. 
    
38. #ifdef __cplusplus
    
39. }
    
40. #endif
    
41. 
    
42. #ifdef __cplusplus
    
43. 
    
44. #include <string>
    
45. #include <list>
    
46. 
    
47. using namespace std;
    
48. 
    
49. // Prefered C++ interface to tracepoint. "name" is an identifier that won't conflict
    
50. // within the scope of calling.
    
51. #define DECLARE_TRACEPOINT(name) tracepoint name (__FILE__, __FUNCTION__, __LINE__)
    
52. 
    
53. struct tracepoint
    
54. {
    
55.   tracepoint ( const char *file, const char *function, int line);
    
56.   tracepoint ( const tracepoint& other );
    
57. 
    
58.   ~tracepoint ();
    
59. 
    
60.   tracepoint & operator= ( const tracepoint & other );
    
61. 
    
62.   private:
    
63.   int *cnt;
    
64. };
    
65. 
    
66. #endif // __cplusplus
    
67. 
    
68. #endif // DEBUG_H
    

复制代码

debug.cpp，实现部分，C++ 代码

1. 
   
2. #include "debug.h"
   
3. 
   
4. static pthread_key_t debug_key;
   
5. static pthread_once_t key_init_once = PTHREAD_ONCE_INIT;
   
6. 
   
7. const char *default_dec[NUM_LEVELS * 2] = {
   
8.   "\033[31mEMERG\033[0m\t", "",
   
9.   "\033[33mERROR\033[0m\t", "",
   
10.   "\033[36mWARNING\033[0m\t", "",
    
11.   "\033[34mINFO\033[0m\t", "",
    
12.   "\033[35mDEBUG\033[0m\t", "",
    
13. };
    
14. 
    
15. struct tp_frame
    
16. {
    
17.   string file, function;
    
18.   int line;
    
19. 
    
20.   tp_frame (const char *f, const char *fn, int l)
    
21.     : file(f), function(fn), line(l), cnt(0)
    
22.   {}
    
23. 
    
24.   ~tp_frame ()
    
25.   { assert( cnt == 0 ); }
    
26. 
    
27.   // Not yet used.
    
28.   tp_frame *get ()
    
29.   { ++cnt; return this; }
    
30. 
    
31.   void put ()
    
32.   { --cnt; }
    
33. 
    
34. private:
    
35.   int cnt;
    
36. };
    
37. 
    
38. struct debug_info
    
39. {
    
40.   debug_info ();
    
41.   ~debug_info ();
    
42. 
    
43.   int ready;
    
44. 
    
45.   int fd;
    
46.   FILE * fp;
    
47.   dbg_level_t level;
    
48.   const char *dec[NUM_LEVELS * 2];
    
49. 
    
50.   // private use below this point
    
51. 
    
52.   char * buf;
    
53.   unsigned bufsz;
    
54. 
    
55.   list < tp_frame *> tracestack;
    
56. 
    
57. };
    
58. 
    
59. debug_info::debug_info ()
    
60.     : ready(false)
    
61. {
    
62.   fd = -1;
    
63.   fp = NULL;
    
64. 
    
65.   int fd = dup (STDERR_FILENO);
    
66.   if ( fd < 0 )
    
67.     goto out;
    
68.   FILE *fp = fdopen (fd, "a");
    
69.   if ( fp == NULL )
    
70.     goto out1;
    
71. 
    
72.   this->fd = fd;
    
73.   this->fp = fp;
    
74. 
    
75.   this->level = EMERG;
    
76. 
    
77.   memcpy (dec, default_dec, sizeof(default_dec));
    
78. 
    
79.   this->buf = NULL;
    
80.   this->bufsz = 0;
    
81. 
    
82.   this->ready = true;
    
83.   return;
    
84. 
    
85. out1:
    
86.   close (fd);
    
87. out:
    
88.   (void)0;
    
89. }
    
90. 
    
91. debug_info::~debug_info ()
    
92. {
    
93.   if ( fp )
    
94.     fclose (fp);
    
95. }
    
96. 
    
97. 
    
98. static void di_dtor (void *pdi)
    
99. {
    
100.   struct debug_info *p = (struct debug_info *)pdi;
     
101.   delete p;
     
102. }
     
103. 
     
104. static void init_key ()
     
105. {
     
106.   pthread_key_create (&debug_key, di_dtor);
     
107. }
     
108. 
     
109. int dbg_enable ()
     
110. {
     
111.   int ret = 0;
     
112.   pthread_once ( &key_init_once, &init_key );
     
113. 
     
114.   debug_info *pdi = new debug_info();
     
115. 
     
116.   ret = (pthread_setspecific (debug_key, pdi));
     
117.   return ret;
     
118. }
     
119. 
     
120. dbg_level_t dbg_level ( dbg_level_t newlvl )
     
121. {
     
122.   struct debug_info *pdi = (struct debug_info *)pthread_getspecific(debug_key);
     
123.   if ( !pdi || !pdi->ready )
     
124.     return EMERG;
     
125.   dbg_level_t rt = pdi->level;
     
126.   if ( (rt != newlvl) && (newlvl != GETVAL) )
     
127.     {
     
128.       pdi->level = newlvl;
     
129.       pthread_setspecific (debug_key, pdi);
     
130.     }
     
131.   return rt;
     
132. }
     
133. 
     
134. void dbg_set_decorate ( char *dec[NUM_LEVELS * 2] )
     
135. {
     
136.   struct debug_info *pdi = (struct debug_info *)pthread_getspecific(debug_key);
     
137.   if ( !pdi || !pdi->ready )
     
138.     return;
     
139.   memcpy( pdi->dec, dec, sizeof(default_dec) );
     
140. }
     
141. 
     
142. int dbg_printf ( dbg_level_t lvl, const char *fmt, ... )
     
143. {
     
144.   struct debug_info *pdi = (struct debug_info *)pthread_getspecific(debug_key);
     
145.   if ( !pdi || !pdi->ready )
     
146.     return 0;
     
147.   if ( lvl > pdi->level )
     
148.     return 0;
     
149. 
     
150.   int rt;
     
151.   va_list ap;
     
152.   va_start (ap, fmt);
     
153. 
     
154.   unsigned sz = pdi->bufsz;
     
155.   char *buf = pdi->buf;
     
156. 
     
157.   if ( buf == NULL )
     
158.     {
     
159.       sz = 32;
     
160.       buf = (char *)malloc(sz);
     
161.       if ( buf == NULL )
     
162.         return 0; // ENOMEM;
     
163.     }
     
164. 
     
165.   const char *pre = pdi->dec[(int)lvl * 2];
     
166.   pre = pre == NULL ? default_dec[(int)lvl * 2] : pre;
     
167.   const char *post = pdi->dec[(int)lvl * 2 + 1];
     
168.   post = post == NULL ? default_dec[(int)lvl * 2 + 1] : post;
     
169. 
     
170.   while ( 1 )
     
171.     {
     
172.       unsigned n;
     
173.       if ( (n = snprintf(buf, sz, "%s%s%s", pre, fmt, post)) > sz )
     
174.         {
     
175.           free (buf);
     
176.           sz = n + 1;
     
177.           buf = (char *)malloc(sz);
     
178.           if ( buf == NULL )
     
179.             return 0; // ENOMEM
     
180.         }
     
181.       else
     
182.         break;
     
183.     }
     
184.   pdi->buf = buf;
     
185.   pdi->bufsz = sz;
     
186. 
     
187.   rt = vfprintf (pdi->fp, pdi->buf, ap);
     
188.   va_end (ap);
     
189. 
     
190.   return rt;
     
191. }
     
192. 
     
193. tracepoint::tracepoint ( const char *file, const char *function, int line )
     
194. {
     
195.   tp_frame *f = new tp_frame(file, function, line);
     
196.   cnt = new int(1);
     
197. 
     
198.   debug_info *p = (debug_info *)pthread_getspecific(debug_key);
     
199.   if ( p )
     
200.     {
     
201.       p->tracestack.push_back (f);
     
202.     }
     
203. }
     
204. 
     
205. tracepoint::tracepoint ( const tracepoint & other )
     
206. {
     
207.   cnt = other.cnt;
     
208.   ++(*cnt);
     
209. }
     
210. 
     
211. tracepoint & tracepoint::operator= ( const tracepoint & other )
     
212. {
     
213.   cnt = other.cnt;
     
214.   ++(*cnt);
     
215.   return *this;
     
216. }
     
217. 
     
218. tracepoint::~tracepoint ()
     
219. {
     
220.   --(*cnt);
     
221.   if ( 0 == *cnt )
     
222.     {
     
223.       debug_info *p = (debug_info *)pthread_getspecific(debug_key);
     
224.       delete p->tracestack.back();
     
225.       p->tracestack.pop_back ();
     
226.       delete cnt;
     
227.     }
     
228. }
     
229. 
     
230. int dbg_dump_stacktrace ()
     
231. {
     
232.   debug_info *p = (debug_info *)pthread_getspecific(debug_key);
     
233.   list < tp_frame *> &s = p->tracestack;
     
234.   while ( s.size() > 0 )
     
235.     {
     
236.       tp_frame *pt = s.back();
     
237.       dbg_printf (EMERG, "%s() at %s:%d\n", pt->function.c_str(), pt->file.c_str(), pt->line);
     
238.       s.pop_back();
     
239.     }
     
240.   fflush(NULL);
     
241.   return 1;
     
242. }
     
243. 
     
244. 
     
245. // Setting / cancelling stack point. C++ should use DECLARE_TRACEPOINT() macro
     
246. void __dbg_enter (const char *file, const char *function, int line)
     
247. {
     
248.   tp_frame *f = new tp_frame(file, function, line);
     
249. 
     
250.   debug_info *p = (debug_info *)pthread_getspecific(debug_key);
     
251.   if ( p )
     
252.     {
     
253.       p->tracestack.push_back (f);
     
254.     }
     
255. 
     
256. }
     
257. 
     
258. void dbg_leave ()
     
259. {
     
260.   debug_info *p = (debug_info *)pthread_getspecific(debug_key);
     
261.   delete p->tracestack.back();
     
262.   p->tracestack.pop_back ();
     
263. }
     

复制代码

测试例程：C 版

1. #include <stdio.h>
   
2. #include <signal.h>
   
3. #include "debug.h"
   
4. 
   
5. void onabrt (int sig) {
   
6.   dbg_dump_stacktrace();
   
7.   fflush(NULL);
   
8.   _exit(127 + sig);
   
9. }
   
10. 
    
11. int main () {
    
12.   // 确保出错的时候自动调用 dump_stacktrace
    
13.   // C++ 程序可以通过注册 SIGABRT 捕获 uncaught_exception，获得类似 Java 的 st 输出
    
14.   signal( SIGSEGV, onabrt );
    
15.   dbg_enable(); // 启用 debug。每个线程都必需。
    
16.   dbg_enter(); // 调用 C 接口设置 stack point。可以嵌套设置多个以缩小调试范围
    
17.   printf ("%d\n", (int)sizeof(long double));
    
18.   *(int *)NULL = 3; // 制造 SIGSEGV
    
19.   dbg_leave(); // 与 dbg_enter() 对应
    
20.   return 0;
    
21. }
    

复制代码

本来设计时候是为了要一个顺手的 logger，没想到最后竟然弄了个 stack trace 的东西出来：）

dbg_printf 用作输出，会自动加上前后缀，并且根据 dbg_set_level 设置的等级确定是否输出。默认的前后缀是等级名称加上 ANSI color code，在 Emacs shell / GDB 中看着像是乱码。可以用 dbg_set_decorate 修改。
Part of OLFS v0.3