Add HPET to recalibrate clock & nano time

Author: maxdev1

kernel/src/kernel/calls/syscall.cpp

@@ -109,6 +109,7 @@ void syscallRegisterAll()
 	_syscallRegister(G_SYSCALL_GET_TASK_FOR_IDENTIFIER, (g_syscall_handler) syscallGetTaskForIdentifier);
 	_syscallRegister(G_SYSCALL_GET_MILLISECONDS, (g_syscall_handler) syscallGetMilliseconds);
 	_syscallRegister(G_SYSCALL_DUMP, (g_syscall_handler) syscallDump);
+	_syscallRegister(G_SYSCALL_GET_NANOSECONDS, (g_syscall_handler) syscallGetNanoseconds);
 
 	// Memory
 	_syscallRegister(G_SYSCALL_LOWER_MEMORY_ALLOCATE, (g_syscall_handler) syscallLowerMemoryAllocate, true);

kernel/src/kernel/calls/syscall_kernquery.cpp

@@ -28,60 +28,65 @@ void syscallKernQuery(g_task* task, g_syscall_kernquery* data)
 {
 	if(data->command == G_KERNQUERY_TASK_LIST)
 	{
-		g_kernquery_task_list_data* kdata = (g_kernquery_task_list_data*) data->buffer;
+		auto out = (g_kernquery_task_list_data*) data->buffer;
 
-		uint32_t rem = kdata->id_buffer_size;
-		kdata->filled_ids = 0;
+		uint32_t rem = out->id_buffer_size;
+		out->filled_ids = 0;
 		auto iter = hashmapIteratorStart(taskGlobalMap);
 		while(rem-- && hashmapIteratorHasNext(&iter))
 		{
 			auto next = hashmapIteratorNext(&iter)->value;
-			kdata->id_buffer[kdata->filled_ids++] = next->id;
+			out->id_buffer[out->filled_ids++] = next->id;
 		}
 		data->status = G_KERNQUERY_STATUS_SUCCESSFUL;
 		hashmapIteratorEnd(&iter);
 	}
 	else if(data->command == G_KERNQUERY_TASK_COUNT)
 	{
-		g_kernquery_task_count_data* kdata = (g_kernquery_task_count_data*) data->buffer;
+		auto out = (g_kernquery_task_count_data*) data->buffer;
 
 		data->status = G_KERNQUERY_STATUS_SUCCESSFUL;
-		kdata->count = hashmapSize(taskGlobalMap);
+		out->count = hashmapSize(taskGlobalMap);
 	}
 	else if(data->command == G_KERNQUERY_TASK_GET_BY_ID)
 	{
-		g_kernquery_task_get_data* kdata = (g_kernquery_task_get_data*) data->buffer;
+		auto out = (g_kernquery_task_get_data*) data->buffer;
 
-		g_task* ktask = taskingGetById(kdata->id);
-		if(!ktask || ktask->status == G_TASK_STATUS_DEAD)
+		g_task* target = taskingGetById(out->id);
+		mutexAcquire(&target->lock);
+
+		if(!target || target->status == G_TASK_STATUS_DEAD)
 		{
 			data->status = G_KERNQUERY_STATUS_UNKNOWN_ID;
-			kdata->id = -1;
+			out->id = -1;
 		}
 		else
 		{
 			data->status = G_KERNQUERY_STATUS_SUCCESSFUL;
-			kdata->found = true;
-			kdata->id = ktask->id;
-			kdata->parent = ktask->process->id;
-			kdata->type = ktask->type;
+			out->found = true;
+			out->id = target->id;
+			out->parent = target->process->id;
+			out->type = target->type;
 
-			if(ktask->process->environment.executablePath)
-				stringCopy(kdata->source_path, ktask->process->environment.executablePath);
+			if(target->process->environment.executablePath)
+				stringCopy(out->source_path, target->process->environment.executablePath);
 			else
-				kdata->source_path[0] = 0;
+				out->source_path[0] = 0;
 
-			const char* identifier = taskingDirectoryGetIdentifier(ktask->id);
+			const char* identifier = taskingDirectoryGetIdentifier(target->id);
 			if(identifier)
-				stringCopy(kdata->identifier, identifier);
+				stringCopy(out->identifier, identifier);
 			else
-				kdata->identifier[0] = 0;
+				out->identifier[0] = 0;
 
-			kdata->memory_used = 0; // TODO
+			out->cpu_time = target->statistics.timesScheduled;
+			out->memory_used = 0; // TODO
 		}
+
+		mutexRelease(&target->lock);
 	}
 	else
 	{
 		data->status = G_KERNQUERY_STATUS_ERROR;
 	}
-}
+}

kernel/src/kernel/calls/syscall_tasking.cpp

@@ -26,6 +26,7 @@
 #include "kernel/tasking/scheduler/scheduler.hpp"
 #include "kernel/tasking/tasking_directory.hpp"
 #include "kernel/tasking/clock.hpp"
+#include "kernel/system/timing/hpet.hpp"
 #include "kernel/utils/wait_queue.hpp"
 #include "shared/logger/logger.hpp"
 #include "shared/utils/string.hpp"
@@ -199,6 +200,14 @@ void syscallGetMilliseconds(g_task* task, g_syscall_millis* data)
 	data->millis = clockGetLocal()->time;
 }
 
+void syscallGetNanoseconds(g_task* task, g_syscall_nanos* data)
+{
+	if(hpetIsAvailable())
+		data->nanos = hpetGetNanos();
+	else
+		data->nanos = clockGetLocal()->time * 1000000LL;
+}
+
 void syscallGetExecutablePath(g_task* task, g_syscall_get_executable_path* data)
 {
 	if(task->process->environment.executablePath)

kernel/src/kernel/calls/syscall_tasking.hpp

@@ -60,6 +60,8 @@ void syscallReleaseCliArguments(g_task* task, g_syscall_cli_args_release* data);
 
 void syscallGetMilliseconds(g_task* task, g_syscall_millis* data);
 
+void syscallGetNanoseconds(g_task* task, g_syscall_nanos* data);
+
 void syscallGetExecutablePath(g_task* task, g_syscall_get_executable_path* data);
 
 void syscallGetWorkingDirectory(g_task* task, g_syscall_get_working_directory* data);

kernel/src/kernel/ipc/pipes.cpp

@@ -42,7 +42,7 @@ g_fs_pipe_status pipeCreate(g_fs_phys_id* outPipeId)
 
 	mutexInitializeTask(&pipe->lock, __func__);
 	pipe->capacity = G_PIPE_DEFAULT_CAPACITY;
-	pipe->buffer = (uint8_t*) memoryAllocateKernelRange(G_PAGE_ALIGN_UP(pipe->capacity) / G_PAGE_SIZE);
+	pipe->buffer = (uint8_t*) memoryAllocateKernel(G_PAGE_ALIGN_UP(pipe->capacity) / G_PAGE_SIZE);
 	pipe->readPosition = pipe->buffer;
 	pipe->writePosition = pipe->buffer;
 	waitQueueInitialize(&pipe->waitersRead);

kernel/src/kernel/memory/memory.cpp

@@ -84,7 +84,7 @@ void memoryPhysicalFree(g_physical_address page)
 		bitmapPageAllocatorMarkFree(&memoryPhysicalAllocator, page);
 }
 
-g_virtual_address memoryAllocateKernelRange(int32_t pages)
+g_virtual_address memoryAllocateKernel(int32_t pages)
 {
 	g_virtual_address virt = addressRangePoolAllocate(memoryVirtualRangePool, pages);
 	for(int32_t i = 0; i < pages; i++)

kernel/src/kernel/memory/memory.hpp

@@ -49,7 +49,7 @@ void memoryPhysicalFree(g_physical_address page);
 /**
  * Allocates and maps a memory range with the given number of pages.
  */
-g_virtual_address memoryAllocateKernelRange(int32_t pages);
+ g_virtual_address memoryAllocateKernel(int32_t pages);
 
 /**
  * Frees a memory range allocated with <memoryAllocateKernelRange>.
@@ -59,7 +59,8 @@ void memoryFreeKernelRange(g_virtual_address address);
 /**
  * Creates an on-demand mapping for a file in memory.
  */
-void memoryOnDemandMapFile(g_process* process, g_fd file, g_offset fileOffset, g_address fileStart, g_ptrsize fileSize, g_ptrsize memorySize);
+void memoryOnDemandMapFile(g_process* process, g_fd file, g_offset fileOffset, g_address fileStart, g_ptrsize fileSize,
+                           g_ptrsize memorySize);
 
 /**
  * Searches for an on-demand mapping containing the given address.

kernel/src/kernel/system/acpi/acpi.cpp

@@ -41,7 +41,7 @@ g_acpi_entry* acpiGetEntryWithSignature(const char* signature)
 		}
 		cur = cur->next;
 	}
-	return 0;
+	return nullptr;
 }
 
 void acpiInitialize()

kernel/src/kernel/system/acpi/acpi.hpp

@@ -28,27 +28,46 @@
 // Set a maximum for SDTs to avoid problems with possible junk tables
 #define	G_SDT_MAXIMUM_BYTES		0x10000
 
+/**
+ * Header of an ACPI table
+ */
 struct g_acpi_table_header
 {
-	uint8_t signature[4];
-	uint32_t length;
-	uint8_t revision;
-	uint8_t checksum;
-	uint8_t oemId[6];
-	uint8_t oemTableId[8];
-	uint32_t oemRevision;
-	uint32_t creatorId;
-	uint32_t creatorRevision;
+    uint8_t signature[4];
+    uint32_t length;
+    uint8_t revision;
+    uint8_t checksum;
+    uint8_t oemId[6];
+    uint8_t oemTableId[8];
+    uint32_t oemRevision;
+    uint32_t creatorId;
+    uint32_t creatorRevision;
 }__attribute__((packed));
 
+
+/**
+ * Generic address structure
+ */
+struct g_acpi_gas
+{
+    uint8_t addressSpace;
+    uint8_t bitWidth;
+    uint8_t bitOffset;
+    uint8_t accessSize;
+    uint64_t address;
+}__attribute__((packed));
+
+/**
+ * Internal listing structure
+ */
 struct g_acpi_entry
 {
-	g_acpi_table_header* header;
-	g_acpi_entry* next;
+    g_acpi_table_header* header;
+    g_acpi_entry* next;
 };
 
 /**
- *
+ * Initializes ACPI by reading the tables
  */
 void acpiInitialize();
 

kernel/src/kernel/system/system.cpp

@@ -24,6 +24,7 @@
 #include "kernel/system/acpi/acpi.hpp"
 #include "kernel/system/interrupts/apic/apic.hpp"
 #include "kernel/system/interrupts/interrupts.hpp"
+#include "kernel/system/timing/hpet.hpp"
 #include "kernel/system/smp.hpp"
 #include "shared/panic.hpp"
 #include "shared/logger/logger.hpp"
@@ -38,6 +39,7 @@ void systemInitializeBsp(g_physical_address initialPdPhys)
 
 	acpiInitialize();
 	apicDetect();
+	hpetInitialize();
 
 	if(!processorListAvailable())
 		panic("%! no processors found", "system");

kernel/src/kernel/system/timing/hpet.cpp

@@ -0,0 +1,84 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                                                                           *
+ *  Ghost, a micro-kernel based operating system for the x86 architecture    *
+ *  Copyright (C) 2025, Max Schlüssel <lokoxe@gmail.com>                     *
+ *                                                                           *
+ *  This program is free software: you can redistribute it and/or modify     *
+ *  it under the terms of the GNU General Public License as published by     *
+ *  the Free Software Foundation, either version 3 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 General Public License for more details.                             *
+ *                                                                           *
+ *  You should have received a copy of the GNU General Public License        *
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.    *
+ *                                                                           *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include "kernel/system/timing/hpet.hpp"
+#include "kernel/memory/memory.hpp"
+#include "kernel/system/acpi/acpi.hpp"
+#include "shared/logger/logger.hpp"
+
+static volatile uint64_t* mmio = nullptr;
+static bool available = false;
+static uint64_t frequency = HPET_DEFAULT_FREQUENCY;
+static double periodsPerSecond = 1.0 / frequency;
+
+void _hpetFindAndMap();
+
+void hpetInitialize()
+{
+	_hpetFindAndMap();
+
+	// Read correct frequency
+	uint64_t capabilities = mmio[HPET_GEN_CAP_REG / 8];
+	uint32_t clockPeriod = (capabilities >> 32) & 0xFFFFFFFF;
+	frequency = (1000000000000000.0 / clockPeriod);
+	periodsPerSecond = 1.0 / frequency;
+
+	// Make sure it is enabled
+	mmio[HPET_GEN_CONFIG_REG / 8] |= 1;
+
+	available = true;
+}
+
+void _hpetFindAndMap()
+{
+	auto entry = acpiGetEntryWithSignature("HPET");
+	if(!entry)
+	{
+		logInfo("%! not present, timing will be inaccurate", "hpet");
+		return;
+	}
+
+	auto hpet = (g_acpi_hpet*) entry->header;
+	if(hpet->baseAddress.addressSpace != 0)
+	{
+		logInfo("%! only supported with MMIO", "hpet");
+		return;
+	}
+
+	auto virtBase = addressRangePoolAllocate(memoryVirtualRangePool, 1);
+	pagingMapPage(virtBase, hpet->baseAddress.address, G_PAGE_TABLE_KERNEL_DEFAULT, G_PAGE_TABLE_KERNEL_DEFAULT,
+	              G_PAGE_KERNEL_UNCACHED);
+
+	mmio = (volatile uint64_t*) virtBase;
+}
+
+bool hpetIsAvailable()
+{
+	return available;
+}
+
+uint64_t hpetGetNanos()
+{
+	if(!available)
+		return 0;
+
+	uint64_t counterValue = mmio[HPET_MAIN_COUNTER_REG / 8];
+	return (uint64_t) ((double) counterValue * periodsPerSecond * 1000000000);
+}