Simplify userspace IRQ handling with g_await_irq; remove "non-interruptible" pipes (dumb idea); add call to create task with core affinity

Author: maxdev1

applications/libps2/src/ps2.cpp

@@ -54,41 +54,27 @@ ps2_status_t ps2Initialize(void (*mouseCallback)(int16_t, int16_t, uint8_t, int8
 	g_irq_create_redirect(1, 1);
 	g_irq_create_redirect(12, 12);
 
-	g_open_irq_device(1, &keyIrqIn);
-	g_create_task((void*) &ps2ReadKeyIrq);
-	g_open_irq_device(12, &mouseIrqIn);
-	g_create_task((void*) &ps2ReadMouseIrq);
+	g_create_task_a((void*) &ps2ReadKeyIrq, 0);
+	g_create_task_a((void*) &ps2ReadMouseIrq, 0);
 	return G_PS2_STATUS_SUCCESS;
 }
 
 void ps2ReadKeyIrq()
 {
 	g_task_register_id("libps2/read-key");
-	uint8_t buf[1];
 	for(;;)
 	{
-		g_fs_read_status stat;
-		g_read_s(keyIrqIn, buf, 1, &stat);
-		if(stat == G_FS_READ_BUSY)
-		{
-			g_sleep(10);
-		}
+		g_await_irq_t(1, 1000);
 		ps2CheckForData();
 	}
 }
 
 void ps2ReadMouseIrq()
 {
 	g_task_register_id("libps2/read-mouse");
-	uint8_t buf[1];
 	for(;;)
 	{
-		g_fs_read_status stat;
-		g_read_s(mouseIrqIn, buf, 1, &stat);
-		if(stat == G_FS_READ_BUSY)
-		{
-			g_sleep(10);
-		}
+		g_await_irq_t(12, 1000);
 		ps2CheckForData();
 	}
 }
@@ -182,6 +168,15 @@ ps2_status_t ps2InitializeMouse()
 
 void ps2HandleMouseData(uint8_t value)
 {
+	static uint64_t lastPacketTime = 0;
+	uint64_t now = g_millis();
+
+	// Reset packet state if too much time has passed
+	if(mousePacketNumber > 0 && (now - lastPacketTime > 50))
+		mousePacketNumber = 0;
+
+	lastPacketTime = now;
+
 	if(mousePacketNumber == 0)
 	{
 		mousePacketBuffer[0] = value;

applications/windowserver/src/windowserver.cpp

@@ -176,8 +176,7 @@ void windowserver_t::updateLoop(const g_rectangle& screenBounds) const
 		output(&global);
 
 		framesTotal++;
-		if(!g_mutex_acquire_to(updateLock, 1000))
-			klog("Times updated: %i", framesTotal);
+		g_mutex_acquire_to(updateLock, 1000);
 
 		auto now = g_millis();
 		if(now - lastUpdate < 10)

kernel/src/kernel/calls/syscall.cpp

@@ -146,7 +146,6 @@ void syscallRegisterAll()
 	_syscallRegister(G_SYSCALL_FS_OPEN_DIRECTORY, (g_syscall_handler) syscallFsOpenDirectory, true);
 	_syscallRegister(G_SYSCALL_FS_READ_DIRECTORY, (g_syscall_handler) syscallFsReadDirectory, true);
 	_syscallRegister(G_SYSCALL_FS_CLOSE_DIRECTORY, (g_syscall_handler) syscallFsCloseDirectory, true);
-	_syscallRegister(G_SYSCALL_OPEN_IRQ_DEVICE, (g_syscall_handler) syscallOpenIrqDevice, true);
 	_syscallRegister(G_SYSCALL_FS_REAL_PATH, (g_syscall_handler) syscallFsRealPath, true);
 
 	// System
@@ -155,6 +154,7 @@ void syscallRegisterAll()
 	_syscallRegister(G_SYSCALL_TEST, (g_syscall_handler) syscallTest);
 	_syscallRegister(G_SYSCALL_CALL_VM86, (g_syscall_handler) syscallCallVm86);
 	_syscallRegister(G_SYSCALL_IRQ_CREATE_REDIRECT, (g_syscall_handler) syscallIrqCreateRedirect);
+	_syscallRegister(G_SYSCALL_AWAIT_IRQ, (g_syscall_handler) syscallAwaitIrq, true);
 
 	// Kernquery
 	_syscallRegister(G_SYSCALL_KERNQUERY, (g_syscall_handler) syscallKernQuery);

kernel/src/kernel/calls/syscall_filesystem.cpp

@@ -98,7 +98,7 @@ void syscallFsTell(g_task* task, g_syscall_fs_tell* data)
 void syscallFsPipe(g_task* task, g_syscall_fs_pipe* data)
 {
 	g_fs_node* pipeNode;
-	data->status = filesystemCreatePipe(data->blocking, &pipeNode, false);
+	data->status = filesystemCreatePipe(data->blocking, &pipeNode);
 
 	if(data->status != G_FS_PIPE_SUCCESSFUL)
 	{
@@ -136,41 +136,6 @@ void syscallFsPipe(g_task* task, g_syscall_fs_pipe* data)
 	data->status = G_FS_PIPE_SUCCESSFUL;
 }
 
-void syscallOpenIrqDevice(g_task* task, g_syscall_open_irq_device* data)
-{
-	if(task->securityLevel <= G_SECURITY_LEVEL_DRIVER)
-	{
-		g_irq_device* irqDevice = requestsGetIrqDevice(data->irq);
-		if(!irqDevice)
-		{
-			data->status = G_OPEN_IRQ_DEVICE_STATUS_ERROR;
-			logInfo("%! task %i: failed to retrieve device for irq %i", "irq", task->id, data->irq);
-			return;
-		}
-
-		irqDevice->task = task->id;
-
-		g_fd fd;
-		g_file_flag_mode readFlags = (G_FILE_FLAG_MODE_READ | G_FILE_FLAG_MODE_BLOCKING);
-		if(filesystemOpenNodeFd(irqDevice->node, readFlags, task->process->id, &fd) == G_FS_OPEN_SUCCESSFUL)
-		{
-			data->status = G_OPEN_IRQ_DEVICE_STATUS_SUCCESSFUL;
-			data->fd = fd;
-			logDebug("%! task %i: opened device for IRQ %i", "irq", task->id, data->irq);
-		}
-		else
-		{
-			data->status = G_OPEN_IRQ_DEVICE_STATUS_ERROR;
-			logInfo("%! task %i: failed to open device for IRQ %i", "irq", task->id, data->irq);
-		}
-	}
-	else
-	{
-		data->status = G_OPEN_IRQ_DEVICE_STATUS_NOT_PERMITTED;
-		logInfo("%! task %i: not permitted to open device for irq %i", "irq", task->id, data->irq);
-	}
-}
-
 void syscallFsOpenDirectory(g_task* task, g_syscall_fs_open_directory* data)
 {
 	auto findRes = filesystemFind(nullptr, data->path);

kernel/src/kernel/calls/syscall_filesystem.hpp

@@ -46,8 +46,6 @@ void syscallFsCloneFd(g_task* task, g_syscall_fs_clonefd* data);
 
 void syscallFsPipe(g_task* task, g_syscall_fs_pipe* data);
 
-void syscallOpenIrqDevice(g_task* task, g_syscall_open_irq_device* data);
-
 void syscallFsOpenDirectory(g_task* task, g_syscall_fs_open_directory* data);
 
 void syscallFsReadDirectory(g_task* task, g_syscall_fs_read_directory* data);

kernel/src/kernel/calls/syscall_system.cpp

@@ -19,6 +19,10 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "kernel/calls/syscall_system.hpp"
+#include "kernel/system/interrupts/interrupts.hpp"
+#include "kernel/system/interrupts/requests.hpp"
+#include "kernel/system/processor/processor.hpp"
+#include "kernel/tasking/clock.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/system/interrupts/apic/ioapic.hpp"
 #include "shared/logger/logger.hpp"
@@ -108,3 +112,32 @@ void syscallIrqCreateRedirect(g_task* task, g_syscall_irq_create_redirect* data)
 
 	ioapicCreateRedirectionEntry(data->source, data->irq, 0);
 }
+
+void syscallAwaitIrq(g_task* task, g_syscall_await_irq* data)
+{
+	if(task->securityLevel > G_SECURITY_LEVEL_DRIVER)
+		return;
+
+	if(processorGetCurrentId() != 0)
+	{
+		logWarn("%! awaiting IRQs only possible on core 0", "call");
+		return taskingExit();
+	}
+
+	requestsSetHandlerTask(data->irq, task->id);
+
+	if(data->timeout)
+		clockUnwaitForTime(task->id);
+
+	INTERRUPTS_PAUSE;
+	mutexAcquire(&task->lock);
+	task->status = G_TASK_STATUS_WAITING;
+	task->waitsFor = "irq";
+	mutexRelease(&task->lock);
+	taskingYield();
+
+	if(data->timeout)
+		clockWaitForTime(task->id, clockGetLocal()->time + data->timeout);
+
+	INTERRUPTS_RESUME;
+}

kernel/src/kernel/calls/syscall_system.hpp

@@ -34,4 +34,6 @@ void syscallCallVm86(g_task* task, g_syscall_call_vm86* data);
 
 void syscallIrqCreateRedirect(g_task* task, g_syscall_irq_create_redirect* data);
 
+void syscallAwaitIrq(g_task* task, g_syscall_await_irq* data);
+
 #endif

kernel/src/kernel/calls/syscall_tasking.cpp

@@ -171,7 +171,14 @@ void syscallCreateTask(g_task* task, g_syscall_create_task* data)
 		newTask->userEntry.data = data->userData;
 		data->threadId = newTask->id;
 		data->status = G_CREATE_TASK_STATUS_SUCCESSFUL;
-		taskingAssignBalanced(newTask);
+
+		if(data->coreAffinity == G_TASK_CORE_AFFINITY_NONE)
+		{
+			taskingAssignBalanced(newTask);
+		} else
+		{
+			taskingAssignOnCore(data->coreAffinity, newTask);
+		}
 	}
 	else
 	{

kernel/src/kernel/filesystem/filesystem.cpp

@@ -379,17 +379,6 @@ g_fs_read_status filesystemRead(g_task* task, g_fd fd, uint8_t* buffer, uint64_t
 		return G_FS_READ_INVALID_FD;
 	}
 
-	if(node->nonInterruptible)
-	{
-		// TODO I don't have a better idea right now, but sometimes the PS/2
-		// device does not seem to fire an interrupt even though data is available
-		// or maybe not, because we are reading in a loop. But this causes the
-		// ps2driver to freeze because it has nothing to read from the blocking
-		// pipe, so to avoid this we wake after some time:
-		clockWaitForTime(task->id, clockGetLocal()->time + 1000);
-		interruptsDisable();
-	}
-
 	int64_t read;
 	g_fs_read_status status;
 	while((status = filesystemRead(node, buffer, descriptor->offset, length, &read)) == G_FS_READ_BUSY
@@ -408,18 +397,11 @@ g_fs_read_status filesystemRead(g_task* task, g_fd fd, uint8_t* buffer, uint64_t
 		delegate->waitForRead(task->id, node);
 		taskingYield();
 		INTERRUPTS_RESUME;
-
-		// TODO
-		if(node->nonInterruptible && clockHasTimedOut(task->id))
-		{
-			status = G_FS_READ_BUSY;
-			break;
-		}
 	}
+
 	if(read > 0)
-	{
 		descriptor->offset += read;
-	}
+
 	*outRead = read;
 	return status;
 }
@@ -471,9 +453,6 @@ g_fs_write_status filesystemWrite(g_task* task, g_fd fd, uint8_t* buffer, uint64
 	if(!node)
 		return G_FS_WRITE_INVALID_FD;
 
-	if(node->nonInterruptible)
-		interruptsDisable();
-
 	uint64_t startOffset = descriptor->offset;
 	if(descriptor->openFlags & G_FILE_FLAG_MODE_APPEND)
 	{
@@ -538,7 +517,7 @@ g_fs_open_status filesystemTruncate(g_fs_node* file)
 	return delegate->truncate(file);
 }
 
-g_fs_pipe_status filesystemCreatePipe(g_bool blocking, g_fs_node** outPipeNode, bool nonInterruptible)
+g_fs_pipe_status filesystemCreatePipe(g_bool blocking, g_fs_node** outPipeNode)
 {
 	g_fs_phys_id pipeId;
 	g_fs_pipe_status status = pipeCreate(&pipeId);
@@ -558,7 +537,6 @@ g_fs_pipe_status filesystemCreatePipe(g_bool blocking, g_fs_node** outPipeNode,
 	g_fs_node* pipeNode = filesystemCreateNode(G_FS_NODE_TYPE_PIPE, pipeName);
 	pipeNode->physicalId = pipeId;
 	pipeNode->blocking = true; // TODO Why does using the parameter freeze everything?
-	pipeNode->nonInterruptible = nonInterruptible;
 	filesystemAddChild(pipesFolder, pipeNode);
 	*outPipeNode = pipeNode;
 	return G_FS_PIPE_SUCCESSFUL;

kernel/src/kernel/filesystem/filesystem.hpp

@@ -48,14 +48,7 @@ struct g_fs_node
 
     bool blocking;
     bool upToDate;
-
-    /**
-     * If a node is non-interruptible, it means that during any read or write
-     * operations, interrupts will be disabled. This is important for example
-     * for IRQ-device pipes to avoid self-deadlocking.
-     */
-    bool nonInterruptible;
-};
+ };
 
 /**
  * An entry in the node tree.
@@ -217,7 +210,7 @@ g_fs_open_status filesystemTruncate(g_fs_node* file);
 /**
  * Creates a new pipe on the filesystem.
  */
-g_fs_pipe_status filesystemCreatePipe(g_bool blocking, g_fs_node** outPipeNode, bool nonInterruptible);
+g_fs_pipe_status filesystemCreatePipe(g_bool blocking, g_fs_node** outPipeNode);
 
 /**
  * Writes the absolute path of node into the given buffer (which must be of G_PATH_MAX bytes size).

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

@@ -19,6 +19,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "kernel/system/interrupts/interrupts.hpp"
+#include "shared/logger/logger.hpp"
 #include "kernel/calls/syscall.hpp"
 #include "kernel/system/interrupts/apic/ioapic.hpp"
 #include "kernel/system/interrupts/apic/lapic.hpp"
@@ -95,9 +96,8 @@ extern "C" volatile g_processor_state* _interruptHandler(volatile g_processor_st
 		}
 		else
 		{
-			requestsWriteToIrqDevice(irq);
+			requestsHandle(task, irq);
 		}
-
 		_interruptsSendEndOfInterrupt(irq);
 	}