foo

arch/ioapic.cc

@@ -71,9 +71,18 @@ void config(uint8_t slot, Core::Interrupt::Vector vector,
 }
 
 void allow(uint8_t slot) {
+    assert(slot < slot_max);
+    RedirectionTableEntry entry = readEntry(slot);
+    entry.interrupt_mask = UNMASKED;
+    writeEntry(slot, entry);
 }
 
-void forbid(uint8_t slot) { (void)slot; }
+void forbid(uint8_t slot) {
+    assert(slot < slot_max);
+    RedirectionTableEntry entry = readEntry(slot);
+    entry.interrupt_mask = MASKED;
+    writeEntry(slot, entry);
+}
 
 bool status(uint8_t slot) {
   (void)slot;

compile_flags.txt

@@ -0,0 +1,2 @@
+-Iarch
+-xc++

debug/assert.cc

@@ -7,7 +7,7 @@
   (void)func;
   (void)file;
   (void)line;
-  DBG << "Assertion failed: " << exp << "\nin function: " << func << "\nfrom file: \"" << file << "\" in line " << line << flush;
+  DBG << "Assertion failed: " << exp << "\nin function: " << func << "\nfrom file: \"" << file << "\" in line " << dec << line << flush;
   // TODO: Print error message (in debug window)
   // TODO: Then stop the current core permanently
   //       Use appropriate method from class Core to do so.

debug/kernelpanic.h

@@ -17,7 +17,7 @@
 #define kernelpanic(MSG)                                                   \
   do {                                                                     \
     DBG << "PANIC: '" << (MSG) << "' in " << __func__ << " @ " << __FILE__ \
-        << ":" << __LINE__ << ") - CPU stopped." << endl;                  \
+        << ":" << dec << __LINE__ << ") - CPU stopped." << endl;                  \
     Core::die();                                                           \
   } while (0)
 

interrupt/handlers.cc

@@ -65,7 +65,9 @@ enum PAGE_FAULT_ERROR {
   kernelpanic("Page fault!");
 }
 
-void handle_keyboard() {}
+void handle_keyboard() {
+    dout[0] << "test"<<endl<<flush;
+}
 
 [[gnu::interrupt]] void handle_panic(InterruptContext *context) {
   DBG << "Generic KernelPanic triggered"<< endl;

main.cc

@@ -1,5 +1,6 @@
 #include "arch/lapic.h"
 #include "boot/startup_ap.h"
+#include "arch/core_interrupt.h"
 #include "debug/copystream.h"
 #include "debug/output.h"
 #include "debug/assert.h"
@@ -119,7 +120,8 @@ extern "C" int main() {
   PS2Controller::init();
 
   IOAPIC::init();
-  //IOAPIC::config(Core::Interrupt::KEYBOARD, Core::Interrupt::Vector vect);
+  IOAPIC::config(1, Core::Interrupt::KEYBOARD);
+  IOAPIC::allow(1);
 
   Core::Interrupt::enable();
 

utils/printf.cc

@@ -0,0 +1,193 @@
+/*
+    Copyright 2001 Georges Menie
+    https://www.menie.org/georges/embedded/small_printf_source_code.html
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*
+	putchar is the only external dependency for this file,
+	if you have a working putchar, just remove the following
+	define. If the function should be called something else,
+	replace outbyte(c) by your own function call.
+*/
+
+static void printchar(char **str, int c)
+{
+	extern int putchar(int c);
+	if (str) {
+		**str = c;
+		++(*str);
+	}
+	//else (void)putchar(c);
+}
+
+#define PAD_RIGHT 1
+#define PAD_ZERO 2
+
+static int prints(char **out, const char *string, int width, int pad)
+{
+	int pc = 0, padchar = ' ';
+
+	if (width > 0) {
+		int len = 0;
+		const char *ptr;
+		for (ptr = string; *ptr; ++ptr) ++len;
+		if (len >= width) width = 0;
+		else width -= len;
+		if (pad & PAD_ZERO) padchar = '0';
+	}
+	if (!(pad & PAD_RIGHT)) {
+		for ( ; width > 0; --width) {
+			printchar (out, padchar);
+			++pc;
+		}
+	}
+	for ( ; *string ; ++string) {
+		printchar (out, *string);
+		++pc;
+	}
+	for ( ; width > 0; --width) {
+		printchar (out, padchar);
+		++pc;
+	}
+
+	return pc;
+}
+
+/* the following should be enough for 32 bit int */
+#define PRINT_BUF_LEN 12
+
+static int printi(char **out, int i, int b, int sg, int width, int pad, int letbase)
+{
+	char print_buf[PRINT_BUF_LEN];
+	char *s;
+	int t, neg = 0, pc = 0;
+	unsigned int u = i;
+
+	if (i == 0) {
+		print_buf[0] = '0';
+		print_buf[1] = '\0';
+		return prints (out, print_buf, width, pad);
+	}
+
+	if (sg && b == 10 && i < 0) {
+		neg = 1;
+		u = -i;
+	}
+
+	s = print_buf + PRINT_BUF_LEN-1;
+	*s = '\0';
+
+	while (u) {
+		t = u % b;
+		if( t >= 10 )
+			t += letbase - '0' - 10;
+		*--s = t + '0';
+		u /= b;
+	}
+
+	if (neg) {
+		if( width && (pad & PAD_ZERO) ) {
+			printchar (out, '-');
+			++pc;
+			--width;
+		}
+		else {
+			*--s = '-';
+		}
+	}
+
+	return pc + prints (out, s, width, pad);
+}
+
+static int print(char **out, int *varg)
+{
+	int width, pad;
+	int pc = 0;
+	char *format = reinterpret_cast<char*>(*varg++);
+	char scr[2];
+
+	for (; *format != 0; ++format) {
+		if (*format == '%') {
+			++format;
+			width = pad = 0;
+			if (*format == '\0') break;
+			if (*format == '%') goto out;
+			if (*format == '-') {
+				++format;
+				pad = PAD_RIGHT;
+			}
+			while (*format == '0') {
+				++format;
+				pad |= PAD_ZERO;
+			}
+			for ( ; *format >= '0' && *format <= '9'; ++format) {
+				width *= 10;
+				width += *format - '0';
+			}
+			if( *format == 's' ) {
+				char *s = *((char **)varg++);
+				pc += prints (out, s?s:"(null)", width, pad);
+				continue;
+			}
+			if( *format == 'd' ) {
+				pc += printi (out, *varg++, 10, 1, width, pad, 'a');
+				continue;
+			}
+			if( *format == 'x' ) {
+				pc += printi (out, *varg++, 16, 0, width, pad, 'a');
+				continue;
+			}
+			if( *format == 'X' ) {
+				pc += printi (out, *varg++, 16, 0, width, pad, 'A');
+				continue;
+			}
+			if( *format == 'u' ) {
+				pc += printi (out, *varg++, 10, 0, width, pad, 'a');
+				continue;
+			}
+			if( *format == 'c' ) {
+				/* char are converted to int then pushed on the stack */
+				scr[0] = *varg++;
+				scr[1] = '\0';
+				pc += prints (out, scr, width, pad);
+				continue;
+			}
+		}
+		else {
+		out:
+			printchar (out, *format);
+			++pc;
+		}
+	}
+	if (out) **out = '\0';
+	return pc;
+}
+
+/* assuming sizeof(void *) == sizeof(int) */
+
+extern "C" int printf(const char *format, ...)
+{
+	int *varg = (int *)(&format);
+	return print(0, varg);
+}
+
+extern "C" int sprintf(char *out, const char *format, ...)
+{
+	int *varg = (int *)(&format);
+	return print(&out, varg);
+}
+

utils/printf.h

@@ -0,0 +1,7 @@
+extern "C" {
+
+int printf(const char *format, ...);
+
+int sprintf(char *out, const char *format, ...);
+
+}