add ability to register debug key combinations so we dont have to put code into the keyboard driver for it

Author: braindigitalis

include/kernel.h

@@ -201,3 +201,5 @@ struct reqset request_addresses(void);
 #endif
 
 void entropy_irq_event(void);
+
+void init_profiler(void);

include/keyboard.h

@@ -74,6 +74,37 @@ struct key_state {
 	uint16_t ticks_held; ///< Number of ticks the key has been held
 };
 
+#define DEBUGKEY_COUNT 256
+#define DEBUGKEY_INVALID 256
+
+/**
+ * @brief Debug key handler
+ */
+typedef void (*debugkey_handler_t)(void);
+
+/**
+ * @brief Register a debug key combination
+ *
+ * @param key Key ('A'-'Z')
+ * @param ctrl Ctrl modifier
+ * @param alt Alt modifier
+ * @param shift Shift modifier
+ * @param handler Handler to invoke
+ *
+ * @return true on success, false on invalid key or NULL handler
+ */
+bool debugkey_register(char key, bool ctrl, bool alt, bool shift, debugkey_handler_t handler);
+
+/**
+ * @brief Unregister a debug key combination
+ *
+ * @param key Key ('A'-'Z')
+ * @param ctrl Ctrl modifier
+ * @param alt Alt modifier
+ * @param shift Shift modifier
+ */
+void debugkey_unregister(char key, bool ctrl, bool alt, bool shift);
+
 /**
  * @brief Initialises the keyboard driver.
  *
@@ -145,4 +176,4 @@ _Noreturn void reboot(void);
  */
 void keyboard_process_scancode_input(uint8_t sc);
 
-bool key_held(unsigned char ch);
+bool key_held(unsigned char ch);

include/memory_trace.h

@@ -83,3 +83,5 @@ void memory_trace_dump_leaks(memory_trace_owner_type_t owner_type, void *owner);
 
 #endif
 
+void init_memtrace(void);
+

src/init.c

@@ -6,6 +6,7 @@ spinlock_t console_spinlock = 0;
 spinlock_t debug_console_spinlock = 0;
 
 init_func_t init_funcs[] = {
+	init_memtrace, init_profiler,
 	validate_limine_page_tables_and_gdt, init_heap, init_console,
 	init_acpi, init_interrupts, boot_aps, init_pci, init_realtime_clock,
 	init_devicenames, init_keyboard, init_ide, init_ahci, init_nvme,
@@ -15,6 +16,7 @@ init_func_t init_funcs[] = {
 };
 
 char* init_funcs_names[] = {
+	"memtrace",	"profiler",
 	"gdt",		"heap",		"console",	"acpi",
 	"interrupts",	"cpus",		"pci",		"clock",
 	"devicenames",	"keyboard",	"ide",		"ahci",	

src/keyboard.c

@@ -16,6 +16,8 @@ static bool alt_state = false;
 static struct key_state key_states[256] = {0};
 static uint8_t key_was_extended[256] = {0};
 
+static debugkey_handler_t debugkeys[256];
+
 /* UK mappings of scan codes to characters, based in part off http://www.ee.bgu.ac.il/~microlab/MicroLab/Labs/ScanCodes.htm
  * These are DEFAULTS. They can be replaced by the KEYMAP BASIC keyword.
  */
@@ -106,7 +108,7 @@ static char parse_token(const char **p)
 		}
 		buf[len] = 0;
 		c = (char)atoll(buf, 16);
-	} else {             /* bare character literal */
+	} else {	     /* bare character literal */
 		c = *s++;
 	}
 
@@ -309,13 +311,21 @@ void keyboard_repeat_tick() {
 	}
 }
 
+static void debugkey_dprintf_dump(void) {
+	const char *log = dprintf_buffer_snapshot();
+	kprintf("\n%s\n", log);
+	kfree_null(&log);
+	return;
+}
+
 void init_keyboard() {
 	char devname[16];
 	buffer_write_ptr = 0;
 	buffer_read_ptr = 0;
 	make_unique_device_name("kb", devname, sizeof(devname));
 	register_interrupt_handler(IRQ1, keyboard_handler, dev_zero, NULL);
 	proc_register_idle(keyboard_repeat_tick, IDLE_BACKGROUND, 1);
+	debugkey_register('D', true, false, true, debugkey_dprintf_dump);
 }
 
 // Map a keyboard scan code to a keymap value
@@ -389,27 +399,57 @@ bool caps_lock_on() {
 	return caps_lock;
 }
 
+static size_t debugkey_index(char key, bool ctrl, bool alt, bool shift) {
+    if (key < 'A' || key > 'Z') {
+	return DEBUGKEY_INVALID;
+    }
+
+    size_t mods =
+	(ctrl  ? 0x20 : 0) |
+	(alt   ? 0x40 : 0) |
+	(shift ? 0x80 : 0);
+
+    return mods | (key - 'A');
+}
+
+bool debugkey_register(char key, bool ctrl, bool alt, bool shift, debugkey_handler_t handler) {
+    size_t idx = debugkey_index(key, ctrl, alt, shift);
+
+    if (idx == DEBUGKEY_INVALID || !handler) {
+	return false;
+    }
+
+    debugkeys[idx] = handler;
+    return true;
+}
+
+void debugkey_unregister(char key, bool ctrl, bool alt, bool shift) {
+    size_t idx = debugkey_index(key, ctrl, alt, shift);
+
+    if (idx != DEBUGKEY_INVALID) {
+	debugkeys[idx] = NULL;
+    }
+}
+
+static bool debugkey_dispatch(char key) {
+    size_t idx = debugkey_index(key, ctrl_held(), alt_held(), shift_held());
+
+    if (idx == DEBUGKEY_INVALID) {
+	return false;
+    }
+
+    debugkey_handler_t handler = debugkeys[idx];
+
+    if (!handler) {
+	return false;
+    }
+
+    handler();
+    return true;
+}
+
 static void push_to_buffer(char x) {
-#ifdef PROFILE_KERNEL
-	if (ctrl_held() && alt_held() && shift_held() && x == 'P') {
-		kprintf("\nDumping callgrind.out to serial port...\n");
-		rr_flip();
-		profile_dump();
-		kprintf("Profile written.\n");
-		rr_flip();
-		return;
-	}
-#endif
-#ifdef MEMORY_TRACE
-	if (ctrl_held() && alt_held() && shift_held() && x == 'M') {
-		memory_trace_dump_leaks(memory_trace_owner_buddy, NULL);
-		memory_trace_dump_leaks(memory_trace_owner_kmalloc, NULL);
-	}
-#endif
-	if (ctrl_held() && shift_held() && x == 'D') {
-		const char *log = dprintf_buffer_snapshot();
-		kprintf("\n%s\n", log);
-		kfree_null(&log);
+	if (debugkey_dispatch(x)) {
 		return;
 	}
 
@@ -439,7 +479,7 @@ void keyboard_process_scancode_input(uint8_t sc) {
 	}
 
 	uint8_t was_escaped = escaped;   /* one-shot */
-	escaped = false;                 /* consume E0 regardless of outcome */
+	escaped = false;		 /* consume E0 regardless of outcome */
 
 	switch (sc) {
 		case 0x2A:

src/memory_trace.c

@@ -227,5 +227,15 @@ void memory_trace_dump_leaks(memory_trace_owner_type_t owner_type, void *owner)
 	}
 }
 
+static void debugkey_memory_trace_dump(void) {
+	memory_trace_dump_leaks(memory_trace_owner_kmalloc, NULL);
+}
+
+#endif
+
+void init_memtrace(void) {
+#ifdef MEMORY_TRACE
+	debugkey_register('M', true, true, true, debugkey_memory_trace_dump);
 #endif
+}
 

src/profiler.c

@@ -79,8 +79,8 @@ static profile_edge* edge_hash[PROFILE_EDGE_HASH_SIZE];
  * @brief Call stack frame used to measure function entry/exit.
  */
 struct call_frame {
-	void *fn;                    /**< Function pointer. */
-	uint64_t enter_time;         /**< Timestamp (TSC) at function entry. */
+	void *fn;		    /**< Function pointer. */
+	uint64_t enter_time;	 /**< Timestamp (TSC) at function entry. */
 	profile_edge *parent_edge;   /**< Edge from the parent to this frame. */
 };
 static struct call_frame call_stack[PROFILE_STACK_DEPTH];
@@ -393,4 +393,19 @@ __attribute__((no_instrument_function)) void profile_dump(void) {
 	}
 }
 
-#endif /* PROFILE_KERNEL */
+void debugkey_profile_dump(void) {
+	kprintf("\nDumping callgrind.out to serial port...\n");
+	rr_flip();
+	profile_dump();
+	kprintf("Profile written.\n");
+	rr_flip();
+	return;		
+}
+
+#endif /* PROFILE_KERNEL */
+
+void init_profiler(void) {
+#ifdef PROFILE_KERNEL
+	debugkey_register('P', true, true, true, debugkey_profile_dump);
+#endif
+}