31d3b3992bf0d90cf5f51e58fa25ef4783135d32
[tpg/acess2.git] / KernelLand / Kernel / debug.c
1 /*
2  * AcessOS Microkernel Version
3  * debug.c
4  */
5 #include <acess.h>
6 #include <stdarg.h>
7
8 #define DEBUG_MAX_LINE_LEN      256
9 #define LOCK_DEBUG_OUTPUT       1       // Avoid interleaving of output lines?
10 #define TRACE_TO_KTERM  0       // Send ENTER/DEBUG/LEAVE to debug?
11
12 // === IMPORTS ===
13 extern void     Threads_Dump(void);
14 extern void     KernelPanic_SetMode(void);
15 extern void     KernelPanic_PutChar(char Ch);
16 extern void     IPStack_SendDebugText(const char *Text);
17
18 // === PROTOTYPES ===
19 static void     Debug_Putchar(char ch);
20 static void     Debug_Puts(int bUseKTerm, const char *Str);
21 void    Debug_DbgOnlyFmt(const char *format, va_list args);
22 void    Debug_FmtS(int bUseKTerm, const char *format, ...);
23 void    Debug_Fmt(int bUseKTerm, const char *format, va_list args);
24 void    Debug_SetKTerminal(const char *File);
25
26 // === GLOBALS ===
27  int    gDebug_Level = 0;
28  int    giDebug_KTerm = -1;
29  int    gbDebug_IsKPanic = 0;
30 volatile int    gbInPutChar = 0;
31 #if LOCK_DEBUG_OUTPUT
32 tShortSpinlock  glDebug_Lock;
33 #endif
34 // - Disabled because it breaks shit
35  int    gbSendNetworkDebug = 0;
36
37 // === CODE ===
38 static void Debug_Putchar(char ch)
39 {
40         Debug_PutCharDebug(ch);
41         
42         if( !gbDebug_IsKPanic )
43         {
44                 if(gbInPutChar) return ;
45                 gbInPutChar = 1;
46                 if(giDebug_KTerm != -1)
47                         VFS_Write(giDebug_KTerm, 1, &ch);
48                 gbInPutChar = 0;
49         }
50         else
51                 KernelPanic_PutChar(ch);
52         
53         if( gbSendNetworkDebug )
54         {
55                 char str[2] = {ch, 0};
56                 IPStack_SendDebugText(str);
57         }
58 }
59
60 static void Debug_Puts(int UseKTerm, const char *Str)
61 {
62          int    len = 0;
63         
64         Debug_PutStringDebug(Str);
65         
66         if( gbDebug_IsKPanic )
67         {               
68                 for( len = 0; Str[len]; len ++ )
69                         KernelPanic_PutChar( Str[len] );
70         }
71         else
72                 for( len = 0; Str[len]; len ++ );
73
74         if( gbSendNetworkDebug )
75                 IPStack_SendDebugText(Str);
76
77         // Output to the kernel terminal
78         if( UseKTerm && !gbDebug_IsKPanic && giDebug_KTerm != -1)
79         {
80                 if(gbInPutChar) return ;
81                 gbInPutChar = 1;
82                 VFS_Write(giDebug_KTerm, len, Str);
83                 gbInPutChar = 0;
84         }
85 }
86
87 void Debug_DbgOnlyFmt(const char *format, va_list args)
88 {
89         Debug_Fmt(0, format, args);
90 }
91
92 void Debug_Fmt(int bUseKTerm, const char *format, va_list args)
93 {
94         char    buf[DEBUG_MAX_LINE_LEN];
95 //       int    len;
96         buf[DEBUG_MAX_LINE_LEN-1] = 0;
97         /*len = */vsnprintf(buf, DEBUG_MAX_LINE_LEN-1, format, args);
98         //if( len < DEBUG_MAX_LINE )
99                 // do something
100         Debug_Puts(bUseKTerm, buf);
101         return ;
102 }
103
104 void Debug_FmtS(int bUseKTerm, const char *format, ...)
105 {
106         va_list args;   
107         va_start(args, format);
108         Debug_Fmt(bUseKTerm, format, args);
109         va_end(args);
110 }
111
112 void Debug_KernelPanic(void)
113 {
114         #if LOCK_DEBUG_OUTPUT
115         SHORTREL(&glDebug_Lock);
116         #endif
117         gbDebug_IsKPanic = 1;
118         KernelPanic_SetMode();
119 }
120
121 /**
122  * \fn void LogF(const char *Msg, ...)
123  * \brief Raw debug log (no new line, no prefix)
124  */
125 void LogF(const char *Fmt, ...)
126 {
127         va_list args;
128
129         #if LOCK_DEBUG_OUTPUT
130         SHORTLOCK(&glDebug_Lock);
131         #endif
132         
133         va_start(args, Fmt);
134
135         Debug_Fmt(1, Fmt, args);
136
137         va_end(args);
138         
139         #if LOCK_DEBUG_OUTPUT
140         SHORTREL(&glDebug_Lock);
141         #endif
142 }
143 /**
144  * \fn void Debug(const char *Msg, ...)
145  * \brief Print only to the debug channel (not KTerm)
146  */
147 void Debug(const char *Fmt, ...)
148 {
149         va_list args;
150         
151         #if LOCK_DEBUG_OUTPUT
152         SHORTLOCK(&glDebug_Lock);
153         #endif
154
155         Debug_Puts(0, "Debug: ");
156         va_start(args, Fmt);
157         Debug_DbgOnlyFmt(Fmt, args);
158         va_end(args);
159         Debug_PutCharDebug('\r');
160         Debug_PutCharDebug('\n');
161         #if LOCK_DEBUG_OUTPUT
162         SHORTREL(&glDebug_Lock);
163         #endif
164 }
165 /**
166  * \fn void Log(const char *Msg, ...)
167  */
168 void Log(const char *Fmt, ...)
169 {
170         va_list args;
171         
172         #if LOCK_DEBUG_OUTPUT
173         SHORTLOCK(&glDebug_Lock);
174         #endif
175
176         Debug_Puts(1, "Log: ");
177         va_start(args, Fmt);
178         Debug_Fmt(1, Fmt, args);
179         va_end(args);
180         Debug_Puts(1, "\r\n");
181         
182         #if LOCK_DEBUG_OUTPUT
183         SHORTREL(&glDebug_Lock);
184         #endif
185 }
186 void Warning(const char *Fmt, ...)
187 {
188         va_list args;
189         
190         #if LOCK_DEBUG_OUTPUT
191         SHORTLOCK(&glDebug_Lock);
192         #endif
193         
194         Debug_Puts(1, "Warning: ");
195         va_start(args, Fmt);
196         Debug_Fmt(1, Fmt, args);
197         va_end(args);
198         Debug_Putchar('\r');
199         Debug_Putchar('\n');
200         
201         #if LOCK_DEBUG_OUTPUT
202         SHORTREL(&glDebug_Lock);
203         #endif
204 }
205 void Panic(const char *Fmt, ...)
206 {
207         va_list args;
208         
209         #if LOCK_DEBUG_OUTPUT
210         SHORTLOCK(&glDebug_Lock);
211         #endif
212         // And never SHORTREL
213         
214         Debug_KernelPanic();
215         
216         Debug_Puts(1, "Panic: ");
217         va_start(args, Fmt);
218         Debug_Fmt(1, Fmt, args);
219         va_end(args);
220         Debug_Putchar('\r');
221         Debug_Putchar('\n');
222
223         Threads_Dump();
224         Heap_Dump();
225
226         for(;;) ;
227 }
228
229 void Debug_SetKTerminal(const char *File)
230 {
231          int    tmp;
232         if(giDebug_KTerm != -1) {
233                 tmp = giDebug_KTerm;
234                 giDebug_KTerm = -1;
235                 VFS_Close(tmp);
236         }
237         tmp = VFS_Open(File, VFS_OPENFLAG_WRITE);
238 //      Log_Log("Debug", "Opened '%s' as 0x%x", File, tmp);
239         giDebug_KTerm = tmp;
240 //      Log_Log("Debug", "Returning to %p", __builtin_return_address(0));
241 }
242
243 void Debug_Enter(const char *FuncName, const char *ArgTypes, ...)
244 {
245         va_list args;
246          int    i;
247          int    pos;
248         tTID    tid = Threads_GetTID();
249          
250         #if LOCK_DEBUG_OUTPUT
251         SHORTLOCK(&glDebug_Lock);
252         #endif
253
254         i = gDebug_Level ++;
255
256         va_start(args, ArgTypes);
257
258         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
259         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
260
261         Debug_Puts(TRACE_TO_KTERM, FuncName);
262         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
263         Debug_Puts(TRACE_TO_KTERM, ": (");
264
265         while(*ArgTypes)
266         {
267                 pos = strpos(ArgTypes, ' ');
268                 if(pos == -1 || pos > 1) {
269                         if(pos == -1)
270                                 Debug_Puts(TRACE_TO_KTERM, ArgTypes+1);
271                         else {
272                                 Debug_FmtS(TRACE_TO_KTERM, "%.*s", pos-1, ArgTypes+1);
273                         }
274                         Debug_Puts(TRACE_TO_KTERM, "=");
275                 }
276                 switch(*ArgTypes)
277                 {
278                 case 'p':       Debug_FmtS(TRACE_TO_KTERM, "%p", va_arg(args, void*));  break;
279                 case 'P':       Debug_FmtS(TRACE_TO_KTERM, "%P", va_arg(args, tPAddr)); break;
280                 case 's':       Debug_FmtS(TRACE_TO_KTERM, "'%s'", va_arg(args, char*));        break;
281                 case 'i':       Debug_FmtS(TRACE_TO_KTERM, "%i", va_arg(args, int));    break;
282                 case 'u':       Debug_FmtS(TRACE_TO_KTERM, "%u", va_arg(args, Uint));   break;
283                 case 'x':       Debug_FmtS(TRACE_TO_KTERM, "0x%x", va_arg(args, Uint)); break;
284                 case 'b':       Debug_FmtS(TRACE_TO_KTERM, "0b%b", va_arg(args, Uint)); break;
285                 case 'X':       Debug_FmtS(TRACE_TO_KTERM, "0x%llx", va_arg(args, Uint64));     break;  // Extended (64-Bit)
286                 case 'B':       Debug_FmtS(TRACE_TO_KTERM, "0b%llb", va_arg(args, Uint64));     break;  // Extended (64-Bit)
287                 }
288                 if(pos != -1) {
289                         Debug_Puts(TRACE_TO_KTERM, ", ");
290                 }
291
292                 if(pos == -1)   break;
293                 ArgTypes = &ArgTypes[pos+1];
294         }
295
296         va_end(args);
297         Debug_Puts(TRACE_TO_KTERM, ")\r\n");
298         
299         #if LOCK_DEBUG_OUTPUT
300         SHORTREL(&glDebug_Lock);
301         #endif
302 }
303
304 void Debug_Log(const char *FuncName, const char *Fmt, ...)
305 {
306         va_list args;
307          int    i = gDebug_Level;
308         tTID    tid = Threads_GetTID();
309
310         #if LOCK_DEBUG_OUTPUT
311         SHORTLOCK(&glDebug_Lock);
312         #endif
313
314         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
315         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
316
317         Debug_Puts(TRACE_TO_KTERM, FuncName);
318         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
319         Debug_Puts(TRACE_TO_KTERM, ": ");
320
321         va_start(args, Fmt);
322         Debug_Fmt(TRACE_TO_KTERM, Fmt, args);
323         va_end(args);
324
325         Debug_Puts(TRACE_TO_KTERM, "\r\n");
326         
327         #if LOCK_DEBUG_OUTPUT
328         SHORTREL(&glDebug_Lock);
329         #endif
330 }
331
332 void Debug_Leave(const char *FuncName, char RetType, ...)
333 {
334         va_list args;
335          int    i;
336         tTID    tid = Threads_GetTID();
337
338         #if LOCK_DEBUG_OUTPUT
339         SHORTLOCK(&glDebug_Lock);
340         #endif
341         
342         i = --gDebug_Level;
343
344         va_start(args, RetType);
345
346         if( i == -1 ) {
347                 gDebug_Level = 0;
348                 i = 0;
349         }
350         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
351         // Indenting
352         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
353
354         Debug_Puts(TRACE_TO_KTERM, FuncName);
355         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
356         Debug_Puts(TRACE_TO_KTERM, ": RETURN");
357
358         // No Return
359         if(RetType == '-') {
360                 Debug_Puts(TRACE_TO_KTERM, "\r\n");
361                 #if LOCK_DEBUG_OUTPUT
362                 SHORTREL(&glDebug_Lock);
363                 #endif
364                 return;
365         }
366
367         switch(RetType)
368         {
369         case 'n':       Debug_Puts(TRACE_TO_KTERM, " NULL");    break;
370         case 'p':       Debug_Fmt(TRACE_TO_KTERM, " %p", args); break;
371         case 'P':       Debug_Fmt(TRACE_TO_KTERM, " %P", args); break;  // PAddr
372         case 's':       Debug_Fmt(TRACE_TO_KTERM, " '%s'", args);       break;
373         case 'i':       Debug_Fmt(TRACE_TO_KTERM, " %i", args); break;
374         case 'u':       Debug_Fmt(TRACE_TO_KTERM, " %u", args); break;
375         case 'x':       Debug_Fmt(TRACE_TO_KTERM, " 0x%x", args);       break;
376         // Extended (64-Bit)
377         case 'X':       Debug_Fmt(TRACE_TO_KTERM, " 0x%llx", args);     break;
378         }
379         Debug_Puts(TRACE_TO_KTERM, "\r\n");
380
381         va_end(args);
382         
383         #if LOCK_DEBUG_OUTPUT
384         SHORTREL(&glDebug_Lock);
385         #endif
386 }
387
388 void Debug_HexDump(const char *Header, const void *Data, Uint Length)
389 {
390         const Uint8     *cdat = Data;
391         Uint    pos = 0;
392         LogF("%014lli ", now());
393         Debug_Puts(1, Header);
394         LogF(" (Hexdump of %p)\r\n", Data);
395
396         #define CH(n)   ((' '<=cdat[(n)]&&cdat[(n)]<0x7F) ? cdat[(n)] : '.')
397
398         while(Length >= 16)
399         {
400                 LogF("%014lli Log: %04x:"
401                         " %02x %02x %02x %02x %02x %02x %02x %02x"
402                         " %02x %02x %02x %02x %02x %02x %02x %02x"
403                         "  %c%c%c%c%c%c%c%c %c%c%c%c%c%c%c%c\r\n",
404                         now(),
405                         pos,
406                         cdat[ 0], cdat[ 1], cdat[ 2], cdat[ 3], cdat[ 4], cdat[ 5], cdat[ 6], cdat[ 7],
407                         cdat[ 8], cdat[ 9], cdat[10], cdat[11], cdat[12], cdat[13], cdat[14], cdat[15],
408                         CH(0),  CH(1),  CH(2),  CH(3),  CH(4),  CH(5),  CH(6),  CH(7),
409                         CH(8),  CH(9),  CH(10), CH(11), CH(12), CH(13), CH(14), CH(15)
410                         );
411                 Length -= 16;
412                 cdat += 16;
413                 pos += 16;
414         }
415
416         {
417                  int    i ;
418                 LogF("%014lli Log: %04x: ", now(), pos);
419                 for(i = 0; i < Length; i ++)
420                 {
421                         LogF("%02x ", cdat[i]);
422                 }
423                 for( ; i < 16; i ++)    LogF("   ");
424                 LogF(" ");
425                 for(i = 0; i < Length; i ++)
426                 {
427                         if( i == 8 )    LogF(" ");
428                         LogF("%c", CH(i));
429                 }
430         
431                 Debug_Putchar('\r');
432                 Debug_Putchar('\n');
433         }
434 }
435
436 // --- EXPORTS ---
437 EXPORT(Debug);
438 EXPORT(Log);
439 EXPORT(Warning);
440 EXPORT(Debug_Enter);
441 EXPORT(Debug_Log);
442 EXPORT(Debug_Leave);

UCC git Repository :: git.ucc.asn.au