Merge branch 'master' of ted.mutabah.net:acess2
[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
225         for(;;) ;
226 }
227
228 void Debug_SetKTerminal(const char *File)
229 {
230          int    tmp;
231         if(giDebug_KTerm != -1) {
232                 tmp = giDebug_KTerm;
233                 giDebug_KTerm = -1;
234                 VFS_Close(tmp);
235         }
236         tmp = VFS_Open(File, VFS_OPENFLAG_WRITE);
237 //      Log_Log("Debug", "Opened '%s' as 0x%x", File, tmp);
238         giDebug_KTerm = tmp;
239 //      Log_Log("Debug", "Returning to %p", __builtin_return_address(0));
240 }
241
242 void Debug_Enter(const char *FuncName, const char *ArgTypes, ...)
243 {
244         va_list args;
245          int    i;
246          int    pos;
247         tTID    tid = Threads_GetTID();
248          
249         #if LOCK_DEBUG_OUTPUT
250         SHORTLOCK(&glDebug_Lock);
251         #endif
252
253         i = gDebug_Level ++;
254
255         va_start(args, ArgTypes);
256
257         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
258         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
259
260         Debug_Puts(TRACE_TO_KTERM, FuncName);
261         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
262         Debug_Puts(TRACE_TO_KTERM, ": (");
263
264         while(*ArgTypes)
265         {
266                 pos = strpos(ArgTypes, ' ');
267                 if(pos == -1 || pos > 1) {
268                         if(pos == -1)
269                                 Debug_Puts(TRACE_TO_KTERM, ArgTypes+1);
270                         else {
271                                 Debug_FmtS(TRACE_TO_KTERM, "%.*s", pos-1, ArgTypes+1);
272                         }
273                         Debug_Puts(TRACE_TO_KTERM, "=");
274                 }
275                 switch(*ArgTypes)
276                 {
277                 case 'p':       Debug_FmtS(TRACE_TO_KTERM, "%p", va_arg(args, void*));  break;
278                 case 'P':       Debug_FmtS(TRACE_TO_KTERM, "%P", va_arg(args, tPAddr)); break;
279                 case 's':       Debug_FmtS(TRACE_TO_KTERM, "'%s'", va_arg(args, char*));        break;
280                 case 'i':       Debug_FmtS(TRACE_TO_KTERM, "%i", va_arg(args, int));    break;
281                 case 'u':       Debug_FmtS(TRACE_TO_KTERM, "%u", va_arg(args, Uint));   break;
282                 case 'x':       Debug_FmtS(TRACE_TO_KTERM, "0x%x", va_arg(args, Uint)); break;
283                 case 'b':       Debug_FmtS(TRACE_TO_KTERM, "0b%b", va_arg(args, Uint)); break;
284                 case 'X':       Debug_FmtS(TRACE_TO_KTERM, "0x%llx", va_arg(args, Uint64));     break;  // Extended (64-Bit)
285                 case 'B':       Debug_FmtS(TRACE_TO_KTERM, "0b%llb", va_arg(args, Uint64));     break;  // Extended (64-Bit)
286                 }
287                 if(pos != -1) {
288                         Debug_Puts(TRACE_TO_KTERM, ", ");
289                 }
290
291                 if(pos == -1)   break;
292                 ArgTypes = &ArgTypes[pos+1];
293         }
294
295         va_end(args);
296         Debug_Puts(TRACE_TO_KTERM, ")\r\n");
297         
298         #if LOCK_DEBUG_OUTPUT
299         SHORTREL(&glDebug_Lock);
300         #endif
301 }
302
303 void Debug_Log(const char *FuncName, const char *Fmt, ...)
304 {
305         va_list args;
306          int    i = gDebug_Level;
307         tTID    tid = Threads_GetTID();
308
309         #if LOCK_DEBUG_OUTPUT
310         SHORTLOCK(&glDebug_Lock);
311         #endif
312
313         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
314         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
315
316         Debug_Puts(TRACE_TO_KTERM, FuncName);
317         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
318         Debug_Puts(TRACE_TO_KTERM, ": ");
319
320         va_start(args, Fmt);
321         Debug_Fmt(TRACE_TO_KTERM, Fmt, args);
322         va_end(args);
323
324         Debug_Puts(TRACE_TO_KTERM, "\r\n");
325         
326         #if LOCK_DEBUG_OUTPUT
327         SHORTREL(&glDebug_Lock);
328         #endif
329 }
330
331 void Debug_Leave(const char *FuncName, char RetType, ...)
332 {
333         va_list args;
334          int    i;
335         tTID    tid = Threads_GetTID();
336
337         #if LOCK_DEBUG_OUTPUT
338         SHORTLOCK(&glDebug_Lock);
339         #endif
340         
341         i = --gDebug_Level;
342
343         va_start(args, RetType);
344
345         if( i == -1 ) {
346                 gDebug_Level = 0;
347                 i = 0;
348         }
349         Debug_FmtS(TRACE_TO_KTERM, "%014lli ", now());
350         // Indenting
351         while(i--)      Debug_Puts(TRACE_TO_KTERM, " ");
352
353         Debug_Puts(TRACE_TO_KTERM, FuncName);
354         Debug_FmtS(TRACE_TO_KTERM, "[%i]", tid);
355         Debug_Puts(TRACE_TO_KTERM, ": RETURN");
356
357         // No Return
358         if(RetType == '-') {
359                 Debug_Puts(TRACE_TO_KTERM, "\r\n");
360                 #if LOCK_DEBUG_OUTPUT
361                 SHORTREL(&glDebug_Lock);
362                 #endif
363                 return;
364         }
365
366         switch(RetType)
367         {
368         case 'n':       Debug_Puts(TRACE_TO_KTERM, " NULL");    break;
369         case 'p':       Debug_Fmt(TRACE_TO_KTERM, " %p", args); break;
370         case 'P':       Debug_Fmt(TRACE_TO_KTERM, " %P", args); break;  // PAddr
371         case 's':       Debug_Fmt(TRACE_TO_KTERM, " '%s'", args);       break;
372         case 'i':       Debug_Fmt(TRACE_TO_KTERM, " %i", args); break;
373         case 'u':       Debug_Fmt(TRACE_TO_KTERM, " %u", args); break;
374         case 'x':       Debug_Fmt(TRACE_TO_KTERM, " 0x%x", args);       break;
375         // Extended (64-Bit)
376         case 'X':       Debug_Fmt(TRACE_TO_KTERM, " 0x%llx", args);     break;
377         }
378         Debug_Puts(TRACE_TO_KTERM, "\r\n");
379
380         va_end(args);
381         
382         #if LOCK_DEBUG_OUTPUT
383         SHORTREL(&glDebug_Lock);
384         #endif
385 }
386
387 void Debug_HexDump(const char *Header, const void *Data, Uint Length)
388 {
389         const Uint8     *cdat = Data;
390         Uint    pos = 0;
391         LogF("%014lli ", now());
392         Debug_Puts(1, Header);
393         LogF(" (Hexdump of %p)\r\n", Data);
394
395         #define CH(n)   ((' '<=cdat[(n)]&&cdat[(n)]<0x7F) ? cdat[(n)] : '.')
396
397         while(Length >= 16)
398         {
399                 LogF("%014lli Log: %04x:"
400                         " %02x %02x %02x %02x %02x %02x %02x %02x"
401                         " %02x %02x %02x %02x %02x %02x %02x %02x"
402                         "  %c%c%c%c%c%c%c%c %c%c%c%c%c%c%c%c\r\n",
403                         now(),
404                         pos,
405                         cdat[ 0], cdat[ 1], cdat[ 2], cdat[ 3], cdat[ 4], cdat[ 5], cdat[ 6], cdat[ 7],
406                         cdat[ 8], cdat[ 9], cdat[10], cdat[11], cdat[12], cdat[13], cdat[14], cdat[15],
407                         CH(0),  CH(1),  CH(2),  CH(3),  CH(4),  CH(5),  CH(6),  CH(7),
408                         CH(8),  CH(9),  CH(10), CH(11), CH(12), CH(13), CH(14), CH(15)
409                         );
410                 Length -= 16;
411                 cdat += 16;
412                 pos += 16;
413         }
414
415         {
416                  int    i ;
417                 LogF("%014lli Log: %04x: ", now(), pos);
418                 for(i = 0; i < Length; i ++)
419                 {
420                         LogF("%02x ", cdat[i]);
421                 }
422                 for( ; i < 16; i ++)    LogF("   ");
423                 LogF(" ");
424                 for(i = 0; i < Length; i ++)
425                 {
426                         if( i == 8 )    LogF(" ");
427                         LogF("%c", CH(i));
428                 }
429         
430                 Debug_Putchar('\r');
431                 Debug_Putchar('\n');
432         }
433 }
434
435 // --- EXPORTS ---
436 EXPORT(Debug);
437 EXPORT(Log);
438 EXPORT(Warning);
439 EXPORT(Debug_Enter);
440 EXPORT(Debug_Log);
441 EXPORT(Debug_Leave);

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