Fix relocations, task PD setup & constants

Author: maxdev1

kernel/inc/shared/memory/constants.hpp

@@ -38,8 +38,8 @@
 
 
 // TODO new constants
-#define G_MEM_LOWER_END                             0x0000000000100000
-#define G_MEM_LOWER_HALF_END                        0x00007fffffffffff
+#define G_MEM_LOWER_END                             0x100000
+#define G_MEM_LOWER_HALF_END                        0x7fffffffffff
 
 /**
  * Due to the Higher Half Direct Map feature, every physical address is mapped
@@ -48,11 +48,11 @@
 #define G_MEM_HIGHER_HALF_DIRECT_MAP_OFFSET         0xffff800000000000
 #define G_MEM_PHYS_TO_VIRT(phys)                    ((G_MEM_HIGHER_HALF_DIRECT_MAP_OFFSET) + (g_address) phys)
 
-#define G_MEM_KERN_VIRT_RANGES_START			    0x00000009f0000000
-#define G_MEM_KERN_VIRT_RANGES_END			        0x00000009ffc00000
-#define G_MEM_HEAP_START                            0x0000000a00000000
-#define G_MEM_HEAP_INITIAL_SIZE                     0x0000000000100000
-#define G_KERNEL_HEAP_EXPAND_STEP			    	0x0000000000100000
+#define G_MEM_KERN_VIRT_RANGES_START			    0xffffff8090000000
+#define G_MEM_KERN_VIRT_RANGES_END			        0xffffff89ffc00000
+#define G_MEM_HEAP_START                            0xffffff8a00000000
+#define G_MEM_HEAP_INITIAL_SIZE                     0x100000
+#define G_MEM_KERN_HEAP_EXPAND_STEP			    	0x100000
 
 
 #endif

kernel/inc/shared/memory/paging.hpp

@@ -49,6 +49,9 @@
 #define G_PDPT_INDEX(addr) (((addr) >> 30) & 0x1FF)
 #define G_PD_INDEX(addr)   (((addr) >> 21) & 0x1FF)
 #define G_PT_INDEX(addr)   (((addr) >> 12) & 0x1FF)
+#define G_PML4_VIRT_ADDRESS(pml4, pdpt, pd, pt) \
+    ((((uint64_t)(pml4) << 39) | ((uint64_t)(pdpt) << 30) | ((uint64_t)(pd) << 21) | ((uint64_t)(pt) << 12)) | \
+    ((((uint64_t)(pml4) & 0x100) ? 0xFFFF000000000000ULL : 0)))
 
 /**
  * Switches to the given page directory.

kernel/src/kernel/memory/gdt.cpp

@@ -53,19 +53,19 @@ void gdtInitializeLocal()
 	_gdtWriteEntry(&localGdt->entry[0], 0, 0, 0, 0);
 
 	// Kernel code segment descriptor, position 0x08
-	_gdtWriteEntry(&localGdt->entry[1], 0, 0, G_ACCESS_BYTE__KERNEL_CODE_SEGMENT,
+	_gdtWriteEntry(&localGdt->entry[1], 0, 0xFFFFFFFF, G_ACCESS_BYTE__KERNEL_CODE_SEGMENT,
 	               G_GDT_GRANULARITY_4KB | G_GDT_GRANULARITY_64BIT);
 
 	// Kernel data segment descriptor, position 0x10
-	_gdtWriteEntry(&localGdt->entry[2], 0, 0, G_ACCESS_BYTE__KERNEL_DATA_SEGMENT,
+	_gdtWriteEntry(&localGdt->entry[2], 0, 0xFFFFFFFF, G_ACCESS_BYTE__KERNEL_DATA_SEGMENT,
 	               G_GDT_GRANULARITY_4KB | G_GDT_GRANULARITY_64BIT);
 
 	// User code segment descriptor, position 0x18
-	_gdtWriteEntry(&localGdt->entry[3], 0, 0, G_ACCESS_BYTE__USER_CODE_SEGMENT,
+	_gdtWriteEntry(&localGdt->entry[3], 0, 0xFFFFFFFF, G_ACCESS_BYTE__USER_CODE_SEGMENT,
 	               G_GDT_GRANULARITY_4KB | G_GDT_GRANULARITY_64BIT);
 
 	// User data segment descriptor, position 0x20
-	_gdtWriteEntry(&localGdt->entry[4], 0, 0, G_ACCESS_BYTE__USER_DATA_SEGMENT,
+	_gdtWriteEntry(&localGdt->entry[4], 0, 0xFFFFFFFF, G_ACCESS_BYTE__USER_DATA_SEGMENT,
 	               G_GDT_GRANULARITY_4KB | G_GDT_GRANULARITY_64BIT);
 
 	// TSS descriptor, position 0x28

kernel/src/kernel/memory/heap.cpp

@@ -123,7 +123,7 @@ uint32_t heapGetUsedAmount()
 
 bool _heapExpand()
 {
-	for(g_virtual_address virt = heapEnd; virt < heapEnd + G_KERNEL_HEAP_EXPAND_STEP; virt += G_PAGE_SIZE)
+	for(g_virtual_address virt = heapEnd; virt < heapEnd + G_MEM_KERN_HEAP_EXPAND_STEP; virt += G_PAGE_SIZE)
 	{
 		g_physical_address phys = memoryPhysicalAllocate(true);
 		if(phys == 0)
@@ -135,8 +135,8 @@ bool _heapExpand()
 		pagingMapPage(virt, phys, G_PAGE_TABLE_KERNEL_DEFAULT, G_PAGE_KERNEL_DEFAULT);
 	}
 
-	memoryAllocatorExpand(&heapAllocator, G_KERNEL_HEAP_EXPAND_STEP);
-	heapEnd += G_KERNEL_HEAP_EXPAND_STEP;
+	memoryAllocatorExpand(&heapAllocator, G_MEM_KERN_HEAP_EXPAND_STEP);
+	heapEnd += G_MEM_KERN_HEAP_EXPAND_STEP;
 
 	logDebug("%! expanded to end %h (%ikb in use)", "kernheap", heapEnd, heapAmountInUse / 1024);
 

kernel/src/kernel/memory/memory.cpp

@@ -31,24 +31,10 @@
 
 g_address_range_pool* memoryVirtualRangePool = nullptr;
 
-// TODO Not sure why this is necessary. Why are kernel pages mapped with user flag initially?
-void pagingRemoveUserPermissions()
-{
-	auto pml4 = (g_address*) G_MEM_PHYS_TO_VIRT(pagingGetCurrentSpace());
-	for(int i = 0; i < 512; i++)
-	{
-		if(pml4[i])
-			pml4[i] &= ~G_PAGE_USER_FLAG;
-	}
-}
-
 void memoryInitialize(limine_memmap_response* memoryMap)
 {
 	logInfo("%! initializing kernel memory with map at %x", "mem", memoryMap);
 
-	logInfo("%! initial data", "paging");
-	pagingRemoveUserPermissions();
-
 	bitmapPageAllocatorInitialize(&memoryPhysicalAllocator, memoryMap);
 	logInfo("%! available: %i MiB", "memory", (memoryPhysicalAllocator.freePageCount * G_PAGE_SIZE) / 1024 / 1024);
 

kernel/src/kernel/system/interrupts/exceptions.cpp

@@ -166,7 +166,7 @@ void exceptionsDumpState(g_task* task, volatile g_processor_state* state)
 bool exceptionsHandlePageFault(g_task* task, volatile g_processor_state* state)
 {
 	g_virtual_address accessed = exceptionsGetCR2();
-	g_physical_address physPage = pagingVirtualToPhysical(G_PAGE_ALIGN_DOWN(accessed));
+	g_physical_address pageEntryValue = pagingVirtualToPageEntry(G_PAGE_ALIGN_DOWN(accessed));
 
 	if(task)
 	{
@@ -176,8 +176,8 @@ bool exceptionsHandlePageFault(g_task* task, volatile g_processor_state* state)
 		if(memoryOnDemandHandlePageFault(task, accessed))
 			return true;
 
-		logInfo("%! (task %i, core %i) RIP: %x (accessed %h, mapped page %h)", "pagefault", task->id,
-		        processorGetCurrentId(), state->rip, accessed, physPage);
+		logInfo("%! (task %i, core %i) RIP: %x (accessed %h, mapping value: %h)", "pagefault", task->id,
+		        processorGetCurrentId(), state->rip, accessed, pageEntryValue);
 
 		exceptionsDumpState(task, state);
 
@@ -194,8 +194,8 @@ bool exceptionsHandlePageFault(g_task* task, volatile g_processor_state* state)
 		return true;
 	}
 
-	logInfo("%! RIP: %x (accessed %h, mapped page %h)", "pagefault", processorGetCurrentId(), state->rip, accessed,
-	        physPage);
+	logInfo("%! RIP: %x (accessed %h, mapping value: %h)", "pagefault", processorGetCurrentId(), state->rip, accessed,
+	        pageEntryValue);
 	return false;
 }
 

kernel/src/kernel/tasking/elf/elf_object.cpp

@@ -349,9 +349,9 @@ void elfObjectApplyRelocations(g_fd file, g_elf_object* object)
 
 			// Symbol lookup
 			if(type == R_X86_64_32 || type == R_X86_64_PC32 ||
-			   type == R_X86_64_GLOB_DAT || type == R_X86_64_JMP_SLOT ||
-			   type == R_X86_64_GOT32 || type == R_X86_64_TLS_TPOFF ||
-			   type == R_X86_64_TLS_DTPMOD32 || type == R_X86_64_TLS_DTPOFF32 ||
+			   type == R_X86_64_GLOB_DAT || type == R_X86_64_JUMP_SLOT ||
+			   type == R_X86_64_GOT32 || type == R_X86_64_TPOFF64 ||
+			   type == R_X86_64_DTPMOD64 || type == R_X86_64_DTPOFF64 ||
 			   type == R_X86_64_COPY)
 			{
 				Elf64_Sym* symbol = &object->dynamicSymbolTable[symbolIndex];
@@ -401,59 +401,65 @@ void elfObjectApplyRelocations(g_fd file, g_elf_object* object)
 			if(type == R_X86_64_32)
 			{
 				int32_t cA = *((int32_t*) cP);
-				*((uint32_t*) cP) = cS + cA;
+				*((uint32_t*) cP) = (uint32_t) (cS + cA);
 			}
 			else if(type == R_X86_64_PC32)
 			{
 				int32_t cA = *((int32_t*) cP);
-				*((uint32_t*) cP) = cS + cA - cP;
+				*((uint32_t*) cP) = (uint32_t) ((uint64_t) cS + cA - (uint64_t) cP);
 			}
 			else if(type == R_X86_64_COPY)
 			{
 				if(cS)
 					memoryCopy((void*) cP, (void*) cS, symbolSize);
 			}
-			else if(type == R_X86_64_GLOB_DAT)
+			else if(type == R_X86_64_GLOB_DAT || type == R_X86_64_JUMP_SLOT)
 			{
-				*((uint32_t*) cP) = cS;
-			}
-			else if(type == R_X86_64_JMP_SLOT)
-			{
-				*((uint32_t*) cP) = cS;
+				*((uint64_t*) cP) = cS;
 			}
 			else if(type == R_X86_64_RELATIVE)
 			{
-				uint32_t cB = object->baseAddress;
+				uint64_t cB = object->baseAddress;
 				int32_t cA = *((int32_t*) cP);
-				*((uint32_t*) cP) = cB + cA;
+				*((uint64_t*) cP) = cB + cA;
+			}
+			else if(type == R_X86_64_64)
+			{
+				int64_t cA = *((int64_t*) cP);
+				*((uint64_t*) cP) = cS + cA;
 			}
-			else if(type == R_X86_64_TLS_TPOFF)
+			else if(type == R_X86_64_TPOFF64)
 			{
-				/**
-				 * For TLS_TPOFF we insert the offset relative to the g_user_threadlocal which is put
-				 * into the segment referenced in GS.
-				 */
 				if(cS)
-					*((uint32_t*) cP) = symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
+					*((uint64_t*) cP) = symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
 					                    symbolInfo.value;
 			}
-			else if(type == R_X86_64_TLS_DTPMOD32)
+			else if(type == R_X86_64_TPOFF32)
 			{
-				/**
-				 * DTPMOD32 expects the module ID to be written which will be passed to ___tls_get_addr.
-				 */
 				if(cS)
-					*((uint32_t*) cP) = symbolInfo.object->id;
+					*((uint32_t*) cP) = (uint32_t) (
+						symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
+						symbolInfo.value);
 			}
-			else if(type == R_X86_64_TLS_DTPOFF32)
+			else if(type == R_X86_64_DTPMOD64)
 			{
-				/**
-				 * DTPOFF32 expects the symbol offset to be written which will be passed to ___tls_get_addr.
-				 */
 				if(cS)
-					*((uint32_t*) cP) = symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
+					*((uint64_t*) cP) = symbolInfo.object->id;
+			}
+			else if(type == R_X86_64_DTPOFF64)
+			{
+				if(cS)
+					*((uint64_t*) cP) = symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
 					                    symbolInfo.value;
 			}
+			else if(type == R_X86_64_DTPOFF32)
+			{
+				if(cS)
+					*((uint32_t*) cP) = (uint32_t) (
+						symbolInfo.object->tlsPart.offset - rootObject->tlsMaster.userThreadOffset +
+						symbolInfo.value);
+			}
+
 
 			entry++;
 		}

kernel/src/kernel/tasking/tasking_memory.cpp

@@ -129,7 +129,7 @@ void taskingMemoryInitializeUtility(g_task* task)
 void taskingMemoryInitializeStacks(g_task* task)
 {
 	// Interrupt stack for ring 3 & VM86 tasks
-	if(task->securityLevel != G_SECURITY_LEVEL_KERNEL || task->type == G_TASK_TYPE_VM86)
+	if(task->securityLevel != G_SECURITY_LEVEL_KERNEL)
 	{
 		task->interruptStack = taskingMemoryCreateStack(memoryVirtualRangePool, G_PAGE_TABLE_KERNEL_DEFAULT,
 		                                                G_PAGE_KERNEL_DEFAULT, G_TASKING_MEMORY_INTERRUPT_STACK_PAGES);
@@ -246,10 +246,10 @@ g_physical_address taskingMemoryCreatePageSpace()
 	g_physical_address newPml4Phys = memoryPhysicalAllocate();
 	auto newPml4 = (g_address*) G_MEM_PHYS_TO_VIRT(newPml4Phys);
 
-	// Copy all kernel privilege mappings
+	// Copy all higher-level mappings
 	for(size_t i = 0; i < 512; i++)
 	{
-		if((currentPml4[i] & G_PAGE_USER_FLAG) == 0)
+		if(i >= 256 && currentPml4[i])
 			newPml4[i] = currentPml4[i];
 		else
 			newPml4[i] = 0;
@@ -309,7 +309,8 @@ void taskingMemoryInitializeTls(g_task* task)
 			// Allocate required virtual range
 			uint32_t requiredSize = process->tlsMaster.size;
 			uint32_t requiredPages = G_PAGE_ALIGN_UP(requiredSize) / G_PAGE_SIZE;
-			if(requiredPages < 1) requiredPages = 1;
+			if(requiredPages < 1)
+				requiredPages = 1;
 
 			g_virtual_address tlsStart = addressRangePoolAllocate(process->virtualRangePool, requiredPages);
 			g_virtual_address tlsEnd = tlsStart + requiredPages * G_PAGE_SIZE;

kernel/src/kernel/utils/debug.cpp

@@ -21,6 +21,8 @@
 #include "kernel/utils/debug.hpp"
 #include "kernel/system/timing/pit.hpp"
 #include "shared/logger/logger.hpp"
+#include "kernel/memory/paging.hpp"
+#include "shared/memory/constants.hpp"
 
 void debugHardSleep(uint64_t millis)
 {
@@ -70,3 +72,53 @@ void hexDump64(void* location, int minus, int plus)
 {
 	hexDump(location, minus, plus, 8);
 }
+
+void debugDumpPageSpace()
+{
+	logInfo("%! debug logging initial space:", "paging");
+	auto pml4 = (g_address*) G_MEM_PHYS_TO_VIRT(pagingGetCurrentSpace());
+	for(int first = 0; first < 512; first++)
+	{
+		if(!pml4[first])
+			continue;
+
+		logInfo("%# %i: %h -> %h %s", first, G_PML4_VIRT_ADDRESS(first, 0, 0, 0), pml4[first],
+		        pml4[first] & G_PAGE_USER_FLAG ? "user" :"kernel");
+		auto pdpt = (g_address*) G_MEM_PHYS_TO_VIRT(G_PAGE_ALIGN_DOWN(pml4[first]));
+		for(int second = 0; second < 512; second++)
+		{
+			if(!pdpt[second])
+				continue;
+
+			logInfo("%# %i > %i: %h -> %h %s", first, second, G_PML4_VIRT_ADDRESS(first, second, 0, 0), pdpt[second],
+			        pdpt[second]& G_PAGE_USER_FLAG ? "user":"kernel");
+			auto pd = (g_address*) G_MEM_PHYS_TO_VIRT(G_PAGE_ALIGN_DOWN(pdpt[second]));
+			for(int third = 0; third < 512; third++)
+			{
+				if(!pd[third])
+					continue;
+
+				logInfo("%# %i > %i > %i: %h -> %h %s", first, second, third,
+				        G_PML4_VIRT_ADDRESS(first, second, third, 0),
+				        pd[third], pd[third]& G_PAGE_USER_FLAG ? "user":"kernel");
+				if(pd[third] & G_PAGE_LARGE_PAGE_FLAG)
+				{
+					logInfo("%#    up to %h", G_PML4_VIRT_ADDRESS(first, second, third, 0) + 0x200000);
+				}
+				else
+				{
+					auto pt = (g_address*) G_MEM_PHYS_TO_VIRT(G_PAGE_ALIGN_DOWN(pd[third]));
+					for(int fourth = 0; fourth < 512; fourth++)
+					{
+						if(!pt[fourth])
+							continue;
+
+						logInfo("%# %i > %i > %i > %i: %h -> %h %s", first, second, third, fourth,
+						        G_PML4_VIRT_ADDRESS(first, second, third, fourth),
+						        pt[fourth], pt[fourth]& G_PAGE_USER_FLAG ? "user":"kernel");
+					}
+				}
+			}
+		}
+	}
+}

kernel/src/kernel/utils/debug.hpp

@@ -29,4 +29,6 @@ void hexDump8(void* location, int minus = 0, int plus = 0);
 
 void hexDump64(void* location, int minus = 0, int plus = 0);
 
+void debugDumpPageSpace();
+
 #endif