SMP AP bootup

Author: braindigitalis

include/acpi.h

@@ -207,3 +207,5 @@ const char *polarity_str(uint8_t pol);
  * @return Descriptive string of the IRQ sharing status
  */
 const char *sharing_str(uint8_t share);
+
+void kmain_ap(struct limine_smp_info *info);

src/acpi.c

@@ -9,6 +9,8 @@ volatile struct limine_rsdp_request rsdp_request = {
 	.revision = 0,
 };
 
+extern volatile struct limine_smp_request smp_request;
+
 static uint8_t lapic_ids[256] = {0}; // CPU core Local APIC IDs
 static uint8_t ioapic_ids[256] = {0}; // CPU core Local APIC IDs
 static uint16_t numcore = 0;         // number of cores detected
@@ -194,6 +196,18 @@ void init_cores() {
 	}
 	if (numcore > 0) {
 		kprintf("SMP: %d cores, %d IOAPICs\n", numcore, numioapic);
+		if (!smp_request.response) {
+			kprintf("No SMP response, running uniprocessor.\n");
+			return;
+		}
+
+		for (uint64_t i = 0; i < smp_request.response->cpu_count; i++) {
+			struct limine_smp_info *cpu = smp_request.response->cpus[i];
+			if (cpu->lapic_id == smp_request.response->bsp_lapic_id) {
+				continue; // Skip BSP
+			}
+			cpu->goto_address = kmain_ap;
+		}
 	}
 	for (int i = 0; i < 16; ++i) {
 		dprintf("IRQ %d maps to GSI %d\n", i, irq_to_gsi(i));

src/ap.c

@@ -1,6 +1,28 @@
 #include <kernel.h>
 
-void kmain_ap()
+volatile struct limine_smp_request smp_request = {
+	.id = LIMINE_SMP_REQUEST,
+	.revision = 0
+};
+
+void kmain_ap(struct limine_smp_info *info)
 {
+	kprintf("CPU: %u online; ID: %u\n", info->processor_id, info->lapic_id);
 	wait_forever();
+	/**
+	 * @todo Insert cpu-local scheduler loop here.
+	 * Each AP will run its own list of executing BASIC processes. Accessing
+	 * the list of other APs and the BSP will be strictly controlled via a
+	 * marshalled lookup system using a spinlock, e.g. if AP 1 wants to check if
+	 * PID X on AP 2 is still running.
+	 *
+	 * This will be done as follows:
+	 *
+	 * 1) Each AP can be instructed via a command queue to launch, query or kill a process.
+	 * 2) Each AP will have its own command queue
+	 * 3) Any AP can push a command onto the command queue for one or more other APs to action
+	 * 4) Initially AP's will wait for a start command in their queue,
+	 *    they won't run their scheduler until they receive this command. This allows them all to
+	 *    gracefully wait until the first BASIC process is ready to be loaded (/programs/init).
+	 */
 }

src/init.c

@@ -2,6 +2,9 @@
 
 typedef void (*init_func_t)(void);
 
+spinlock_t console_spinlock = 0;
+spinlock_t debug_console_spinlock = 0;
+
 init_func_t init_funcs[] = {
 	init_heap, validate_limine_page_tables_and_gdt, init_console,
 	init_cores, init_idt, init_pci, init_realtime_clock,
@@ -23,6 +26,8 @@ char* init_funcs_names[] = {
 
 void init()
 {
+	init_spinlock(&debug_console_spinlock);
+	init_spinlock(&console_spinlock);
 	uint32_t n = 0;
 	for (init_func_t* func = init_funcs; *func; ++func) {
 		dprintf("Bringing up %s...\n", init_funcs_names[n]);

src/printf.c

@@ -1,6 +1,9 @@
 #include <kernel.h>
 #include <string.h>
 
+extern spinlock_t console_spinlock;
+extern spinlock_t debug_console_spinlock;
+
 static int do_printf(const char *fmt, size_t max, va_list args, fnptr_t fn, void *ptr)
 {
 	unsigned flags = 0, actual_wd = 0, count = 0, given_wd = 0;
@@ -276,17 +279,23 @@ int dvprintf_help(unsigned c, [[maybe_unused]] void **ptr, [[maybe_unused]] cons
 
 int vprintf(const char *fmt, va_list args)
 {
-	return do_printf(fmt, SIZE_MAX, args, vprintf_help, NULL);
+	lock_spinlock(&console_spinlock);
+	int r = do_printf(fmt, SIZE_MAX, args, vprintf_help, NULL);
+	unlock_spinlock(&console_spinlock);
+	return r;
 }
 
 int dvprintf(const char *fmt, va_list args)
 {
 	char counter[25];
+	lock_spinlock(&debug_console_spinlock);
 	do_itoa(get_ticks(), counter, 10);
 	dput('[');
 	dputstring(counter);
 	dputstring("]: ");
-	return do_printf(fmt, SIZE_MAX, args, dvprintf_help, NULL);
+	int r = do_printf(fmt, SIZE_MAX, args, dvprintf_help, NULL);
+	unlock_spinlock(&debug_console_spinlock);
+	return r;
 }
 
 int printf(const char *fmt, ...)