Almost fixed 64 bit AP trampoline code

Author: maxdev1

kernel/build.sh

@@ -70,7 +70,7 @@ target_compile_ap_startup() {
 
 	$NASM -f bin -o "$AP_STARTUP_OBJ" -s "$AP_STARTUP_SRC"
 	failOnError
-	mv "$AP_STARTUP_OBJ" "$AP_STARTUP_TGT"
+	cp "$AP_STARTUP_OBJ" "$AP_STARTUP_TGT"
 	list $AP_STARTUP_OBJ
 }
 

kernel/inc/shared/memory/constants.hpp

@@ -21,13 +21,13 @@
 #ifndef __MEMORY_CONSTANTS__
 #define __MEMORY_CONSTANTS__
 
-#define G_SMP_STARTUP_AREA				            0x00000500
-#define G_SMP_STARTUP_AREA_PAGEDIR		            0x00000500	// initial page directory address is put here
-#define G_SMP_STARTUP_AREA_AP_ENTRY	                0x00000504	// kernel entry point for AP
-#define G_SMP_STARTUP_AREA_AP_COUNTER		      	0x00000508	// counter for stack array indexing
-#define G_SMP_STARTUP_AREA_AP_STACK_ARRAY	    	0x0000050C	// array of stacks
-#define G_SMP_STARTUP_AREA_CODE_START		    	0x00001000	// must be 000XX000, used for SIPI
-#define G_SMP_STARTUP_AREA_END				        0x00007BFF
+#define G_SMP_STARTUP_AREA				            0x500
+#define G_SMP_STARTUP_AREA_PAGEDIR		            0x500	// initial page directory address is put here
+#define G_SMP_STARTUP_AREA_AP_ENTRY	                0x508	// kernel entry point for AP
+#define G_SMP_STARTUP_AREA_AP_COUNTER		      	0x510	// counter for stack pointer array indexing
+#define G_SMP_STARTUP_AREA_AP_STACK_ARRAY	    	0x518	// array of stack pointers
+#define G_SMP_STARTUP_AREA_CODE_START		    	0x1000	// must be 000XX000, used for SIPI
+#define G_SMP_STARTUP_AREA_END				        0x7BFF
 
 // TODO change values
 #define G_USER_MAXIMUM_HEAP_BREAK				    0xA0000000

kernel/src/ap/ap_startup.asm

@@ -37,7 +37,7 @@
 ; Loaded by the kernel to this location
 org 0x1000
 
-; Initial setup
+; Real mode
 BITS 16
 startup:
 	; Load the GDT
@@ -49,13 +49,13 @@ startup:
     mov cr0, eax
 
 	; Far-JMP into protected mode code
-    jmp 0x08:protectedStart
+    jmp 0x8:protectedStart
 
 
-; Protected mode for 64-bit (transition to 64-bit long mode)
-BITS 64
+; Protected mode
+BITS 32
 protectedStart:
-	; Set up code segments for 64-bit mode
+	; Code segments were set by far JMP, set data segments
     mov ax, 0x10
     mov ds, ax
     mov es, ax
@@ -64,70 +64,97 @@ protectedStart:
     mov ss, ax
 
 	; Lock all cores
-	acquireLock:
-    lock bts qword [interlock], 0
+    acquireLock:
+    lock bts dword [interlock], 0
     jc acquireLock
 
-	    ; Set page directory
-	    mov rax, [0x500]
-	    mov cr3, rax
+    ; Enable PAE
+    mov eax, cr4
+    or eax, 1 << 5
+    mov cr4, eax
 
-		; Enable paging
-	    mov rax, cr0
-	    or rax, 0x80000000
-	    mov cr0, rax
+    ; Set page directory
+    mov eax, [0x500]
+    mov cr3, eax
 
-	    ; Set "global pages" flag
-	    mov rax, cr4
-	    or rax, 0x80
-	    mov cr4, rax
+    ; Enable PGE
+    mov eax, cr4
+    or eax, 1 << 7
+    mov cr4, eax
 
-		; Load stack from stack array
-		mov rax, [0x508]		; current index
-		shl rax, 2				; multiply by 4 (size of one entry)
-		mov rsp, [0x50C + rax]	; move entry to RSP
-		mov rbp, rsp
+    ; Set up EFER MSR to enable long mode (EFER.LME)
+    mov ecx, 0xC0000080
+    rdmsr
+    or eax, 1 << 8
+    wrmsr
 
-		; Increment AP counter
-		inc qword [0x508]
+    ; Enable paging
+    mov eax, cr0
+    or eax, 1 << 31
+    mov cr0, eax
+
+    ; Get index of this AP and increment counter
+    mov eax, [0x510]
+    inc dword [0x510]
 
 	; Release lock
-    lock btr qword [interlock], 0
+    lock btr dword [interlock], 0
+
+	; Far-jump to 64 bits
+	jmp 0x18:longStart
 
-	; Jump to kernel
-	call [0x504]
+; Long mode
+[BITS 64]
+longStart:
+    ; Set data segments
+    mov bx, 0x10
+    mov ds, bx
+    mov ss, bx
 
-	; AP should never exit, just for safety
-	hang:
-	hlt
-	jmp hang
+    ; 32-bit code provides AP index in EAX
+    ; From the stack array, take the entry at offset multiplied by 8
+    shl rax, 3
+    mov rsp, [0x518 + rax]
+    mov rbp, rsp
 
+	; Jump into kernel code
+    mov rax, [0x508]
+    jmp rax
 
 ; Inter-core synchronization
 interlock:
-	dd 0x00000000
+	dd 0
 
 
 ; Pointer to the GDT
 gdtPointer:
-	dw 24
+	dw 31
 	dd gdt
 
-; Basic setup GDT for x86_64
+; Basic setup GDT
 gdt:
 	; null descriptor
-	dq 0x0000000000000000
+	dw 0x0000
+	dw 0x0000
+	dw 0x0000
+	dw 0x0000
 
-	; code descriptor (64-bit)
+	; code descriptor
 	dw 0xFFFF
 	dw 0x0000
-	dw 0x9A00
+	dw 0x9800
 	dw 0x00CF
-	dq 0x0000000000000000
 
-	; data descriptor (64-bit)
+	; data descriptor
 	dw 0xFFFF
 	dw 0x0000
 	dw 0x9200
 	dw 0x00CF
-	dq 0x0000000000000000
+
+	; code descriptor (64-bit)
+	dw 0xFFFF
+	dw 0x0000
+	dw 0x9A00
+	dw 0x00A0
+
+    ; TODO 64 bit data segment?

kernel/src/kernel/system/smp.cpp

@@ -26,31 +26,51 @@
 #include "kernel/kernel.hpp"
 #include "shared/memory/constants.hpp"
 #include "shared/logger/logger.hpp"
+#include "kernel/memory/paging.hpp"
 
 bool smpInitialized = false;
 
 void smpInitialize(g_physical_address initialPageDirectoryPhysical)
 {
+	// TODO: For all physical allocations below we must make sure that the memory is in 32 bit address range
+
+	// Identity-map lower memory
+	for(g_address phys = 0; phys < G_SMP_STARTUP_AREA_END; phys += G_PAGE_SIZE)
+	{
+		pagingMapPage(phys, phys, G_PAGE_TABLE_KERNEL_DEFAULT, G_PAGE_KERNEL_DEFAULT);
+		logInfo("Identitiy map %x to %x: %x", phys, phys, pagingVirtualToPhysical(phys));
+	}
+
+	// Map it so we can write it here
+	g_virtual_address mappedLower = addressRangePoolAllocate(memoryVirtualRangePool,
+	                                                         G_PAGE_ALIGN_UP(G_SMP_STARTUP_AREA_END) / G_PAGE_SIZE);
+	for(g_address phys = 0; phys < G_SMP_STARTUP_AREA_END; phys += G_PAGE_SIZE)
+	{
+		pagingMapPage(mappedLower + phys, phys, G_PAGE_TABLE_KERNEL_DEFAULT, G_PAGE_KERNEL_DEFAULT);
+	}
+
 	// Write values to lower memory for use within startup code
-	*((uint32_t*) G_SMP_STARTUP_AREA_PAGEDIR) = initialPageDirectoryPhysical;
-	*((uint32_t*) G_SMP_STARTUP_AREA_AP_ENTRY) = (g_virtual_address) kernelRunApplicationCore;
-	*((uint32_t*) G_SMP_STARTUP_AREA_AP_COUNTER) = 0;
+	*((g_address*) (mappedLower + G_SMP_STARTUP_AREA_PAGEDIR)) = initialPageDirectoryPhysical;
+	*((g_address*) (mappedLower + G_SMP_STARTUP_AREA_AP_ENTRY)) = (g_virtual_address) kernelRunApplicationCore;
+	*((g_size*) (mappedLower + G_SMP_STARTUP_AREA_AP_COUNTER)) = 0;
 
-	logDebug("%! initial page directory for APs: %h", "smp", *((uint32_t*) G_SMP_STARTUP_AREA_PAGEDIR));
-	logDebug("%! kernel entry point for APs: %h", "smp", *((uint32_t*) G_SMP_STARTUP_AREA_AP_ENTRY));
-	logDebug("%! initial AP counter value: %i", "smp", *((uint32_t*) G_SMP_STARTUP_AREA_AP_COUNTER));
+	logInfo("%! initial page directory for APs: %h, %x", "smp",
+	        *((g_address*) (mappedLower+G_SMP_STARTUP_AREA_PAGEDIR)),
+	        initialPageDirectoryPhysical);
+	logInfo("%! kernel entry point for APs: %h", "smp", *((g_address*) (mappedLower+G_SMP_STARTUP_AREA_AP_ENTRY)));
+	logInfo("%! initial AP counter value: %i", "smp", *((uint32_t*) (mappedLower+G_SMP_STARTUP_AREA_AP_COUNTER)));
 
 	// Create enough stacks for all APs
-	g_physical_address* stackArray = (g_physical_address*) G_SMP_STARTUP_AREA_AP_STACK_ARRAY;
+	auto stackArray = (g_physical_address*) (mappedLower + G_SMP_STARTUP_AREA_AP_STACK_ARRAY);
 	for(uint32_t i = 0; i < processorGetNumberOfProcessors(); i++)
 	{
-
 		g_physical_address stackPhysical = memoryPhysicalAllocate();
 		if(stackPhysical == 0)
 		{
 			logInfo("%*%! could not allocate physical page for AP stack", 0x0C, "smp");
 			return;
 		}
+
 		g_virtual_address stackVirtual = addressRangePoolAllocate(memoryVirtualRangePool, 1);
 		if(stackPhysical == 0)
 		{
@@ -63,18 +83,19 @@ void smpInitialize(g_physical_address initialPageDirectoryPhysical)
 		g_virtual_address stackTop = (stackVirtual + G_PAGE_SIZE);
 		stackArray[i] = stackTop;
 
-		logDebug("%! created AP stack (%h) placed at %h", "smp", stackArray[i], &stackArray[i]);
+		logInfo("%! created AP stack (%h -> %h) placed at %h", "smp", stackArray[i], stackPhysical,
+		        ((g_address)&stackArray[i]) - mappedLower);
 	}
 
 	// Copy start object from ramdisk to lower memory
-	const char* ap_startup_location = "system/lib/apstartup.o";
-	g_ramdisk_entry* startupObject = ramdiskFindAbsolute(ap_startup_location);
-	if(startupObject == 0)
+	const char* apStartupPath = "system/lib/apstartup.o";
+	g_ramdisk_entry* startupObject = ramdiskFindAbsolute(apStartupPath);
+	if(startupObject == nullptr)
 	{
-		logInfo("%*%! could not initialize due to missing apstartup object at '%s'", 0x0C, "smp", ap_startup_location);
+		logInfo("%*%! could not initialize due to missing apstartup object at '%s'", 0x0C, "smp", apStartupPath);
 		return;
 	}
-	memoryCopy((uint8_t*) G_SMP_STARTUP_AREA_CODE_START, (uint8_t*) startupObject->data, startupObject->dataSize);
+	memoryCopy((uint8_t*) (mappedLower + G_SMP_STARTUP_AREA_CODE_START), startupObject->data, startupObject->dataSize);
 
 	smpInitialized = true;
 
@@ -88,6 +109,8 @@ void smpInitialize(g_physical_address initialPageDirectoryPhysical)
 		}
 		core = core->next;
 	}
+
+	logInfo("%! initial AP counter value: %i", "smp", *((uint32_t*) (mappedLower+G_SMP_STARTUP_AREA_AP_COUNTER)));
 }
 
 void smpInitializeCore(g_processor* cpu)