X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fdebug.c;h=57964bdee8324cc93b8ec27542969e18f6f0718e;hb=54bf151b1a05b74debdb5f3baec02c18406b74d1;hp=e8e181d5b41dbb3d59a794225795ec01a40f470b;hpb=7d2f8503550796a3cd42d01f944c2baa49a2fcfa;p=tpg%2Facess2.git

diff --git a/Kernel/debug.c b/Kernel/debug.c
index e8e181d5..57964bde 100644
--- a/Kernel/debug.c
+++ b/Kernel/debug.c
@@ -1,271 +1,216 @@
 /*
  * AcessOS Microkernel Version
  * debug.c
+ * 
+ * TODO: Move the Debug_putchar methods out to the arch/ tree
  */
 #include <acess.h>
 #include <stdarg.h>
 
-#define DEBUG_TO_E9	1
-#define DEBUG_TO_SERIAL	1
-#define	SERIAL_PORT	0x3F8
-#define	GDB_SERIAL_PORT	0x2F8
+#define	DEBUG_MAX_LINE_LEN	256
+
+#define	LOCK_DEBUG_OUTPUT	1
 
 // === IMPORTS ===
-extern void Threads_Dump();
+extern void Threads_Dump(void);
+extern void	KernelPanic_SetMode(void);
+extern void	KernelPanic_PutChar(char Ch);
+
+// === PROTOTYPES ===
+static void	Debug_Putchar(char ch);
+static void	Debug_Puts(int DbgOnly, const char *Str);
+void	Debug_DbgOnlyFmt(const char *format, va_list args);
+void	Debug_FmtS(const char *format, ...);
+void	Debug_Fmt(const char *format, va_list args);
+void	Debug_SetKTerminal(const char *File);
 
 // === GLOBALS ===
  int	gDebug_Level = 0;
  int	giDebug_KTerm = -1;
- int	gbDebug_SerialSetup = 0;
- int	gbGDB_SerialSetup = 0;
+ int	gbDebug_IsKPanic = 0;
+volatile int	gbInPutChar = 0;
+#if LOCK_DEBUG_OUTPUT
+tShortSpinlock	glDebug_Lock;
+#endif
 
 // === CODE ===
-int putDebugChar(char ch)
-{
-	if(!gbGDB_SerialSetup) {
-		outb(GDB_SERIAL_PORT + 1, 0x00);    // Disable all interrupts
-		outb(GDB_SERIAL_PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
-		outb(GDB_SERIAL_PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
-		outb(GDB_SERIAL_PORT + 1, 0x00);    //                  (hi byte)
-		outb(GDB_SERIAL_PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
-		outb(GDB_SERIAL_PORT + 2, 0xC7);    // Enable FIFO with 14-byte threshold and clear it
-		outb(GDB_SERIAL_PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
-		gbDebug_SerialSetup = 1;
-	}
-	while( (inb(GDB_SERIAL_PORT + 5) & 0x20) == 0 );
-	outb(GDB_SERIAL_PORT, ch);
-	return 0;
-}
-int getDebugChar()
-{
-	if(!gbGDB_SerialSetup) {
-		outb(GDB_SERIAL_PORT + 1, 0x00);    // Disable all interrupts
-		outb(GDB_SERIAL_PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
-		outb(GDB_SERIAL_PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
-		outb(GDB_SERIAL_PORT + 1, 0x00);    //                  (hi byte)
-		outb(GDB_SERIAL_PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
-		outb(GDB_SERIAL_PORT + 2, 0xC7);    // Enable FIFO with 14-byte threshold and clear it
-		outb(GDB_SERIAL_PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
-		gbDebug_SerialSetup = 1;
+static void Debug_Putchar(char ch)
+{	
+	Debug_PutCharDebug(ch);
+	if( !gbDebug_IsKPanic )
+	{
+		if(gbInPutChar)	return ;
+		gbInPutChar = 1;
+		if(giDebug_KTerm != -1)
+			VFS_Write(giDebug_KTerm, 1, &ch);
+		gbInPutChar = 0;
 	}
-	while( (inb(GDB_SERIAL_PORT + 5) & 1) == 0)	;
-	return inb(GDB_SERIAL_PORT);
+	else
+		KernelPanic_PutChar(ch);
 }
 
-volatile int	gbInPutChar = 0;
-
-static void Debug_Putchar(char ch)
+static void Debug_Puts(int UseKTerm, const char *Str)
 {
-	#if DEBUG_TO_E9
-	__asm__ __volatile__ ( "outb %%al, $0xe9" :: "a"(((Uint8)ch)) );
-	#endif
+	 int	len = 0;
+	
+	Debug_PutStringDebug(Str);
 	
-	#if DEBUG_TO_SERIAL
-	if(!gbDebug_SerialSetup) {
-		outb(SERIAL_PORT + 1, 0x00);	// Disable all interrupts
-		outb(SERIAL_PORT + 3, 0x80);	// Enable DLAB (set baud rate divisor)
-		outb(SERIAL_PORT + 0, 0x03);	// Set divisor to 3 (lo byte) 38400 baud
-		outb(SERIAL_PORT + 1, 0x00);	//                  (hi byte)
-		outb(SERIAL_PORT + 3, 0x03);	// 8 bits, no parity, one stop bit
-		outb(SERIAL_PORT + 2, 0xC7);	// Enable FIFO with 14-byte threshold and clear it
-		outb(SERIAL_PORT + 4, 0x0B);	// IRQs enabled, RTS/DSR set
-		gbDebug_SerialSetup = 1;
+	if( gbDebug_IsKPanic )
+	{		
+		for( len = 0; Str[len]; len ++ )
+			KernelPanic_PutChar( Str[len] );
 	}
-	while( (inb(SERIAL_PORT + 5) & 0x20) == 0 );
-	outb(SERIAL_PORT, ch);
-	#endif
+	else
+		for( len = 0; Str[len]; len ++ );
 	
-	if(gbInPutChar)	return ;
-	gbInPutChar = 1;
-	if(giDebug_KTerm != -1)
-		VFS_Write(giDebug_KTerm, 1, &ch);
-	gbInPutChar = 0;
+	// Output to the kernel terminal
+	if( UseKTerm && !gbDebug_IsKPanic && giDebug_KTerm != -1)
+	{
+		if(gbInPutChar)	return ;
+		gbInPutChar = 1;
+		VFS_Write(giDebug_KTerm, len, Str);
+		gbInPutChar = 0;
+	}
 }
 
-static void Debug_Puts(char *Str)
+void Debug_DbgOnlyFmt(const char *format, va_list args)
 {
-	while(*Str)	Debug_Putchar(*Str++);
+	char	buf[DEBUG_MAX_LINE_LEN];
+	 int	len;
+	buf[DEBUG_MAX_LINE_LEN-1] = 0;
+	len = vsnprintf(buf, DEBUG_MAX_LINE_LEN-1, format, args);
+	//if( len < DEBUG_MAX_LINE )
+		// do something
+	Debug_Puts(0, buf);
 }
 
-void Debug_Fmt(const char *format, va_list *args)
+void Debug_Fmt(const char *format, va_list args)
 {
-	char	c, pad = ' ';
-	 int	minSize = 0, len;
-	char	tmpBuf[34];	// For Integers
-	char	*p = NULL;
-	 int	isLongLong = 0;
-	Uint64	arg;
-	 int	bPadLeft = 0;
-
-	while((c = *format++) != 0)
-	{
-		// Non control character
-		if( c != '%' ) {
-			Debug_Putchar(c);
-			continue;
-		}
-
-		c = *format++;
-
-		// Literal %
-		if(c == '%') {
-			Debug_Putchar('%');
-			continue;
-		}
-
-		// Pointer
-		if(c == 'p') {
-			Uint	ptr = va_arg(*args, Uint);
-			Debug_Putchar('*');	Debug_Putchar('0');	Debug_Putchar('x');
-			p = tmpBuf;
-			itoa(p, ptr, 16, BITS/4, '0');
-			goto printString;
-		}
+	char	buf[DEBUG_MAX_LINE_LEN];
+	 int	len;
+	buf[DEBUG_MAX_LINE_LEN-1] = 0;
+	len = vsnprintf(buf, DEBUG_MAX_LINE_LEN-1, format, args);
+	//if( len < DEBUG_MAX_LINE )
+		// do something
+	Debug_Puts(1, buf);
+	return ;
+}
 
-		// Get Argument
-		arg = va_arg(*args, Uint);
+void Debug_FmtS(const char *format, ...)
+{
+	va_list	args;	
+	va_start(args, format);
+	Debug_Fmt(format, args);
+	va_end(args);
+}
 
-		// - Padding Side Flag
-		if(c == '+') {
-			bPadLeft = 1;
-			c = *format++;
-		}
+void Debug_KernelPanic()
+{
+	gbDebug_IsKPanic = 1;
+	KernelPanic_SetMode();
+}
 
-		// Padding
-		if(c == '0') {
-			pad = '0';
-			c = *format++;
-		} else
-			pad = ' ';
+/**
+ * \fn void LogF(const char *Msg, ...)
+ * \brief Raw debug log (no new line, no prefix)
+ */
+void LogF(const char *Fmt, ...)
+{
+	va_list	args;
 
-		// Minimum length
-		minSize = 1;
-		if('1' <= c && c <= '9')
-		{
-			minSize = 0;
-			while('0' <= c && c <= '9')
-			{
-				minSize *= 10;
-				minSize += c - '0';
-				c = *format++;
-			}
-		}
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
+	
+	va_start(args, Fmt);
 
-		// Long (default)
-		isLongLong = 0;
-		if(c == 'l') {
-			c = *format++;
-			if(c == 'l') {
-				#if BITS == 32
-				arg |= va_arg(*args, Uint);
-				#endif
-				c = *format++;
-				isLongLong = 1;
-			}
-		}
+	Debug_Fmt(Fmt, args);
 
-		p = tmpBuf;
-		switch (c) {
-		case 'd':
-		case 'i':
-			if( (isLongLong && arg >> 63) || (!isLongLong && arg >> 31) ) {
-				Debug_Putchar('-');
-				arg = -arg;
-			}
-			itoa(p, arg, 10, minSize, pad);
-			goto printString;
-		case 'u':
-			itoa(p, arg, 10, minSize, pad);
-			goto printString;
-		case 'x':
-			itoa(p, arg, 16, minSize, pad);
-			goto printString;
-		case 'o':
-			itoa(p, arg, 8, minSize, pad);
-			goto printString;
-		case 'b':
-			itoa(p, arg, 2, minSize, pad);
-			goto printString;
-
-		printString:
-			if(!p)		p = "(null)";
-			while(*p)	Debug_Putchar(*p++);
-			break;
-
-		case 'B':	//Boolean
-			if(arg)	Debug_Puts("True");
-			else	Debug_Puts("False");
-			break;
-
-		case 's':
-			p = (char*)(Uint)arg;
-			if(!p)		p = "(null)";
-			len = strlen(p);
-			if( !bPadLeft )	while(len++ < minSize)	Debug_Putchar(pad);
-			while(*p)	Debug_Putchar(*p++);
-			if( bPadLeft )	while(len++ < minSize)	Debug_Putchar(pad);
-			break;
-
-		// Single Character / Array
-		case 'c':
-			if(minSize == 1) {
-				Debug_Putchar(arg);
-				break;
-			}
-			p = (char*)(Uint)arg;
-			if(!p)	goto printString;
-			while(minSize--)	Debug_Putchar(*p++);
-			break;
-
-		default:
-			Debug_Putchar(arg);
-			break;
-		}
-    }
+	va_end(args);
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
-
 /**
- * \fn void LogF(char *Msg, ...)
+ * \fn void Debug(const char *Msg, ...)
+ * \brief Print only to the debug channel (not KTerm)
  */
-void LogF(char *Fmt, ...)
+void Debug(const char *Fmt, ...)
 {
 	va_list	args;
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
 
+	Debug_Puts(0, "Debug: ");
 	va_start(args, Fmt);
-
-	Debug_Fmt(Fmt, &args);
-
+	Debug_DbgOnlyFmt(Fmt, args);
 	va_end(args);
+	Debug_PutCharDebug('\r');
+	Debug_PutCharDebug('\n');
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
 /**
- * \fn void Log(char *Msg, ...)
+ * \fn void Log(const char *Msg, ...)
  */
-void Log(char *Fmt, ...)
+void Log(const char *Fmt, ...)
 {
 	va_list	args;
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
 
-	Debug_Puts("Log: ");
+	Debug_Puts(1, "Log: ");
 	va_start(args, Fmt);
-	Debug_Fmt(Fmt, &args);
+	Debug_Fmt(Fmt, args);
 	va_end(args);
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
-void Warning(char *Fmt, ...)
+void Warning(const char *Fmt, ...)
 {
 	va_list	args;
-	Debug_Puts("Warning: ");
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
+	
+	Debug_Puts(1, "Warning: ");
 	va_start(args, Fmt);
-	Debug_Fmt(Fmt, &args);
+	Debug_Fmt(Fmt, args);
 	va_end(args);
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
-void Panic(char *Fmt, ...)
+void Panic(const char *Fmt, ...)
 {
 	va_list	args;
-	Debug_Puts("Panic: ");
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
+	// And never SHORTREL
+	
+	Debug_KernelPanic();
+	
+	Debug_Puts(1, "Panic: ");
 	va_start(args, Fmt);
-	Debug_Fmt(Fmt, &args);
+	Debug_Fmt(Fmt, args);
 	va_end(args);
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
 
 	Threads_Dump();
@@ -275,7 +220,7 @@ void Panic(char *Fmt, ...)
 	for(;;)	__asm__ __volatile__ ("hlt");
 }
 
-void Debug_SetKTerminal(char *File)
+void Debug_SetKTerminal(const char *File)
 {
 	 int	tmp;
 	if(giDebug_KTerm != -1) {
@@ -289,38 +234,50 @@ void Debug_SetKTerminal(char *File)
 	Log_Log("Debug", "Returning to %p", __builtin_return_address(0));
 }
 
-void Debug_Enter(char *FuncName, char *ArgTypes, ...)
+void Debug_Enter(const char *FuncName, const char *ArgTypes, ...)
 {
 	va_list	args;
-	 int	i = gDebug_Level ++;
+	 int	i;
 	 int	pos;
+	tTID	tid = Threads_GetTID();
+	 
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
+
+	i = gDebug_Level ++;
 
 	va_start(args, ArgTypes);
 
+	LogF("%012lli ", now());
 	while(i--)	Debug_Putchar(' ');
 
-	Debug_Puts(FuncName);	Debug_Puts(": (");
+	Debug_Puts(1, FuncName);
+	Debug_FmtS("[%i]", tid);
+	Debug_Puts(1, ": (");
 
 	while(*ArgTypes)
 	{
 		pos = strpos(ArgTypes, ' ');
-		if(pos != -1)	ArgTypes[pos] = '\0';
 		if(pos == -1 || pos > 1) {
-			Debug_Puts(ArgTypes+1);
+			if(pos == -1)
+				Debug_Puts(1, ArgTypes+1);
+			else {
+				for( i = 1; i < pos; i ++ )
+					Debug_Putchar(ArgTypes[i]);
+			}
 			Debug_Putchar('=');
 		}
-		if(pos != -1)	ArgTypes[pos] = ' ';
 		switch(*ArgTypes)
 		{
-		case 'p':	Debug_Fmt("%p", &args);	break;
-		case 's':	Debug_Fmt("'%s'", &args);	break;
-		case 'i':	Debug_Fmt("%i", &args);	break;
-		case 'u':	Debug_Fmt("%u", &args);	break;
-		case 'x':	Debug_Fmt("0x%x", &args);	break;
-		case 'b':	Debug_Fmt("0b%b", &args);	break;
-		// Extended (64-Bit)
-		case 'X':	Debug_Fmt("0x%llx", &args);	break;
-		case 'B':	Debug_Fmt("0b%llb", &args);	break;
+		case 'p':	LogF("%p", va_arg(args, void*));	break;
+		case 's':	LogF("'%s'", va_arg(args, char*));	break;
+		case 'i':	LogF("%i", va_arg(args, int));	break;
+		case 'u':	LogF("%u", va_arg(args, Uint));	break;
+		case 'x':	LogF("0x%x", va_arg(args, Uint));	break;
+		case 'b':	LogF("0b%b", va_arg(args, Uint));	break;
+		case 'X':	LogF("0x%llx", va_arg(args, Uint64));	break;	// Extended (64-Bit)
+		case 'B':	LogF("0b%llb", va_arg(args, Uint64));	break;	// Extended (64-Bit)
 		}
 		if(pos != -1) {
 			Debug_Putchar(',');	Debug_Putchar(' ');
@@ -331,29 +288,53 @@ void Debug_Enter(char *FuncName, char *ArgTypes, ...)
 	}
 
 	va_end(args);
-	Debug_Putchar(')');	Debug_Putchar('\n');
+	Debug_Putchar(')');	Debug_Putchar('\r');	Debug_Putchar('\n');
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
 
-void Debug_Log(char *FuncName, char *Fmt, ...)
+void Debug_Log(const char *FuncName, const char *Fmt, ...)
 {
 	va_list	args;
 	 int	i = gDebug_Level;
+	tTID	tid = Threads_GetTID();
+
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
 
 	va_start(args, Fmt);
 
+	LogF("%012lli ", now());
 	while(i--)	Debug_Putchar(' ');
 
-	Debug_Puts(FuncName);	Debug_Puts(": ");
-	Debug_Fmt(Fmt, &args);
+	Debug_Puts(1, FuncName);
+	Debug_FmtS("[%i]", tid);
+	Debug_Puts(1, ": ");
+	Debug_Fmt(Fmt, args);
 
 	va_end(args);
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
 
-void Debug_Leave(char *FuncName, char RetType, ...)
+void Debug_Leave(const char *FuncName, char RetType, ...)
 {
 	va_list	args;
-	 int	i = --gDebug_Level;
+	 int	i;
+	tTID	tid = Threads_GetTID();
+
+	#if LOCK_DEBUG_OUTPUT
+	SHORTLOCK(&glDebug_Lock);
+	#endif
+	
+	i = --gDebug_Level;
 
 	va_start(args, RetType);
 
@@ -361,44 +342,57 @@ void Debug_Leave(char *FuncName, char RetType, ...)
 		gDebug_Level = 0;
 		i = 0;
 	}
+	LogF("%012lli ", now());
 	// Indenting
 	while(i--)	Debug_Putchar(' ');
 
-	Debug_Puts(FuncName);	Debug_Puts(": RETURN");
+	Debug_Puts(1, FuncName);
+	Debug_FmtS("[%i]", tid);
+	Debug_Puts(1, ": RETURN");
 
 	// No Return
 	if(RetType == '-') {
+		Debug_Putchar('\r');
 		Debug_Putchar('\n');
+		#if LOCK_DEBUG_OUTPUT
+		SHORTREL(&glDebug_Lock);
+		#endif
 		return;
 	}
 
 	Debug_Putchar(' ');
 	switch(RetType)
 	{
-	case 'n':	Debug_Puts("NULL");	break;
-	case 'p':	Debug_Fmt("%p", &args);	break;
-	case 's':	Debug_Fmt("'%s'", &args);	break;
-	case 'i':	Debug_Fmt("%i", &args);	break;
-	case 'u':	Debug_Fmt("%u", &args);	break;
-	case 'x':	Debug_Fmt("0x%x", &args);	break;
+	case 'n':	Debug_Puts(1, "NULL");	break;
+	case 'p':	Debug_Fmt("%p", args);	break;
+	case 's':	Debug_Fmt("'%s'", args);	break;
+	case 'i':	Debug_Fmt("%i", args);	break;
+	case 'u':	Debug_Fmt("%u", args);	break;
+	case 'x':	Debug_Fmt("0x%x", args);	break;
 	// Extended (64-Bit)
-	case 'X':	Debug_Fmt("0x%llx", &args);	break;
+	case 'X':	Debug_Fmt("0x%llx", args);	break;
 	}
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
 
 	va_end(args);
+	
+	#if LOCK_DEBUG_OUTPUT
+	SHORTREL(&glDebug_Lock);
+	#endif
 }
 
-void Debug_HexDump(char *Header, void *Data, Uint Length)
+void Debug_HexDump(const char *Header, const void *Data, Uint Length)
 {
-	Uint8	*cdat = Data;
+	const Uint8	*cdat = Data;
 	Uint	pos = 0;
-	Debug_Puts(Header);
-	LogF(" (Hexdump of %p)\n", Data);
+	Debug_Puts(1, Header);
+	LogF(" (Hexdump of %p)\r\n", Data);
+
+	#define	CH(n)	((' '<=cdat[(n)]&&cdat[(n)]<=0x7F) ? cdat[(n)] : '.')
 
 	while(Length >= 16)
 	{
-		#define	CH(n)	((' '<=cdat[(n)]&&cdat[(n)]<=0x7F) ? cdat[(n)] : '.')
 		Log("%04x: %02x %02x %02x %02x %02x %02x %02x %02x"
 			" %02x %02x %02x %02x %02x %02x %02x %02x"
 			"  %c%c%c%c%c%c%c%c %c%c%c%c%c%c%c%c",
@@ -413,18 +407,28 @@ void Debug_HexDump(char *Header, void *Data, Uint Length)
 		pos += 16;
 	}
 
-	LogF("Log: %04x: ", pos);
-	while(Length)
 	{
-		Uint	byte = *cdat;
-		LogF("%02x ", byte);
-		Length--;
-		cdat ++;
+		 int	i ;
+		LogF("Log: %04x: ", pos);
+		for(i = 0; i < Length; i ++)
+		{
+			LogF("%02x ", cdat[i]);
+		}
+		for( ; i < 16; i ++)	LogF("   ");
+		LogF(" ");
+		for(i = 0; i < Length; i ++)
+		{
+			if( i == 8 )	LogF(" ");
+			LogF("%c", CH(i));
+		}
 	}
+	
+	Debug_Putchar('\r');
 	Debug_Putchar('\n');
 }
 
 // --- EXPORTS ---
+EXPORT(Debug);
 EXPORT(Log);
 EXPORT(Warning);
 EXPORT(Debug_Enter);