Implement a generic taskingWait function to avoid explicitly dealing with correct interrupt disabling/locking order everywhere; add g_task_await_by_id to allow waiting until a task registers with an identifier

Author: maxdev1

kernel/src/kernel/calls/syscall.cpp

@@ -110,6 +110,7 @@ void syscallRegisterAll()
 	_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);
+	_syscallRegister(G_SYSCALL_AWAIT_TASK_BY_IDENTIFIER, (g_syscall_handler) syscallAwaitTaskByIdentifier);
 
 	// Memory
 	_syscallRegister(G_SYSCALL_LOWER_MEMORY_ALLOCATE, (g_syscall_handler) syscallLowerMemoryAllocate, true);
@@ -129,7 +130,7 @@ void syscallRegisterAll()
 	// Messages
 	_syscallRegister(G_SYSCALL_MESSAGE_SEND, (g_syscall_handler) syscallMessageSend);
 	_syscallRegister(G_SYSCALL_MESSAGE_RECEIVE, (g_syscall_handler) syscallMessageReceive);
-	_syscallRegister(G_SYSCALL_MESSAGE_NEXT_TXID, (g_syscall_handler) syscallMessageNextTxid);
+	_syscallRegister(G_SYSCALL_MESSAGE_NEXT_TXID, (g_syscall_handler) syscallMessageNextTxId);
 
 	// Filesystem
 	_syscallRegister(G_SYSCALL_FS_OPEN, (g_syscall_handler) syscallFsOpen, true);

kernel/src/kernel/calls/syscall_messaging.cpp

@@ -21,22 +21,17 @@
 #include "kernel/calls/syscall_messaging.hpp"
 #include "kernel/ipc/message.hpp"
 #include "kernel/tasking/user_mutex.hpp"
-#include "kernel/system/interrupts/interrupts.hpp"
 
 void syscallMessageSend(g_task* task, g_syscall_send_message* data)
 {
 	while((data->status = messageSend(task->id, data->receiver, data->buffer, data->length, data->transaction)) ==
 	      G_MESSAGE_SEND_STATUS_QUEUE_FULL &&
 	      data->mode == G_MESSAGE_SEND_MODE_BLOCKING)
 	{
-		INTERRUPTS_PAUSE;
-		mutexAcquire(&task->lock);
-		task->status = G_TASK_STATUS_WAITING;
-		task->waitsFor = "message-send";
-		mutexRelease(&task->lock);
-		messageWaitForSend(task->id, data->receiver);
-		taskingYield();
-		INTERRUPTS_RESUME;
+		taskingWait(task, __func__, [task, data]()
+		{
+			messageWaitForSend(task->id, data->receiver);
+		});
 	}
 	messageUnwaitForSend(task->id, data->receiver);
 }
@@ -47,27 +42,17 @@ void syscallMessageReceive(g_task* task, g_syscall_receive_message* data)
 	      G_MESSAGE_RECEIVE_STATUS_QUEUE_EMPTY &&
 	      data->mode == G_MESSAGE_RECEIVE_MODE_BLOCKING)
 	{
-		/**
-		 * TODO: "Break condition" doesn't work anymore since there is no connection between mutexes and
-		 * the message wait queues. This must be somehow connected and the task waken when required.
-		 */
+		// TODO: "Break condition" can't work anymore:
 		// if(data->break_condition && userMutexAcquire(task, data->break_condition, true, false))
 		//{
 		//	data->status = G_MESSAGE_RECEIVE_STATUS_INTERRUPTED;
 		//	break;
 		// }
-
-		INTERRUPTS_PAUSE;
-		mutexAcquire(&task->lock);
-		task->status = G_TASK_STATUS_WAITING;
-		task->waitsFor = "message-recv";
-		mutexRelease(&task->lock);
-		taskingYield();
-		INTERRUPTS_RESUME;
+		taskingWait(task, __func__);
 	}
 }
 
-void syscallMessageNextTxid(g_task* task, g_syscall_message_next_txid* data)
+void syscallMessageNextTxId(g_task* task, g_syscall_message_next_txid* data)
 {
 	data->transaction = messageNextTxId();
 }

kernel/src/kernel/calls/syscall_messaging.hpp

@@ -28,6 +28,6 @@ void syscallMessageSend(g_task* task, g_syscall_send_message* data);
 
 void syscallMessageReceive(g_task* task, g_syscall_receive_message* data);
 
-void syscallMessageNextTxid(g_task * task, g_syscall_message_next_txid * data);
+void syscallMessageNextTxId(g_task* task, g_syscall_message_next_txid* data);
 
 #endif

kernel/src/kernel/calls/syscall_system.cpp

@@ -19,7 +19,6 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #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"
@@ -125,19 +124,12 @@ void syscallAwaitIrq(g_task* task, g_syscall_await_irq* data)
 	}
 
 	requestsSetHandlerTask(data->irq, task->id);
-
-	INTERRUPTS_PAUSE;
-	mutexAcquire(&task->lock);
-	task->status = G_TASK_STATUS_WAITING;
-	task->waitsFor = "irq";
-	mutexRelease(&task->lock);
-
-	if(data->timeout)
+	taskingWait(task, __func__, [data, task]()
 	{
-		clockUnwaitForTime(task->id);
-		clockWaitForTime(task->id, clockGetLocal()->time + data->timeout);
-	}
-
-	taskingYield();
-	INTERRUPTS_RESUME;
+		if(data->timeout)
+		{
+			clockUnwaitForTime(task->id);
+			clockWaitForTime(task->id, clockGetLocal()->time + data->timeout);
+		}
+	});
 }

kernel/src/kernel/calls/syscall_tasking.cpp

@@ -33,14 +33,10 @@
 
 void syscallSleep(g_task* task, g_syscall_sleep* data)
 {
-	INTERRUPTS_PAUSE;
-	mutexAcquire(&task->lock);
-	task->status = G_TASK_STATUS_WAITING;
-	task->waitsFor = "sleeps";
-	mutexRelease(&task->lock);
-	clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);
-	taskingYield();
-	INTERRUPTS_RESUME;
+	taskingWait(task, __func__, [task, data]()
+	{
+		clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);
+	});
 }
 
 void syscallYield(g_task* task, g_syscall_yield* data)
@@ -88,14 +84,10 @@ void syscallGetProcessIdForTaskId(g_task* task, g_syscall_get_pid_for_tid* data)
 
 void syscallJoin(g_task* task, g_syscall_join* data)
 {
-	INTERRUPTS_PAUSE;
-	mutexAcquire(&task->lock);
-	task->status = G_TASK_STATUS_WAITING;
-	task->waitsFor = "join";
-	mutexRelease(&task->lock);
-	taskingWaitForExit(data->taskId, task->id);
-	taskingYield();
-	INTERRUPTS_RESUME;
+	taskingWait(task, __func__, [task ,data]()
+	{
+		taskingWaitForExit(data->taskId, task->id);
+	});
 }
 
 void syscallSpawn(g_task* task, g_syscall_spawn* data)
@@ -175,7 +167,8 @@ void syscallCreateTask(g_task* task, g_syscall_create_task* data)
 		if(data->coreAffinity == G_TASK_CORE_AFFINITY_NONE)
 		{
 			taskingAssignBalanced(newTask);
-		} else
+		}
+		else
 		{
 			taskingAssignOnCore(data->coreAffinity, newTask);
 		}
@@ -293,6 +286,21 @@ void syscallRegisterTaskIdentifier(g_task* task, g_syscall_task_id_register* dat
 	data->successful = taskingDirectoryRegister(data->identifier, task->id, task->securityLevel);
 }
 
+void syscallAwaitTaskByIdentifier(g_task* task, g_syscall_task_await_by_id* data)
+{
+	g_tid target;
+	while((target = taskingDirectoryGet(data->identifier)) == G_TID_NONE)
+	{
+		taskingWait(task, __func__, [data, task]()
+		{
+			clockWaitForTime(task->id, clockGetLocal()->time + 100);
+			taskingDirectoryWaitForRegister(data->identifier, task->id);
+		});
+		clockUnwaitForTime(task->id);
+	}
+	data->task = target;
+}
+
 void syscallGetTaskForIdentifier(g_task* task, g_syscall_task_id_get* data)
 {
 	data->resultTaskId = taskingDirectoryGet(data->identifier);

kernel/src/kernel/calls/syscall_tasking.hpp

@@ -70,6 +70,8 @@ void syscallSetWorkingDirectory(g_task* task, g_syscall_set_working_directory* d
 
 void syscallRegisterTaskIdentifier(g_task* task, g_syscall_task_id_register* data);
 
+void syscallAwaitTaskByIdentifier(g_task* task, g_syscall_task_await_by_id* data);
+
 void syscallGetTaskForIdentifier(g_task* task, g_syscall_task_id_get* data);
 
 void syscallDump();

kernel/src/kernel/memory/heap.cpp

@@ -108,26 +108,6 @@ uint32_t heapGetUsedAmount()
 	return heapAmountInUse;
 }
 
-void* operator new(size_t size)
-{
-	return heapAllocate(size);
-}
-
-void* operator new[](size_t size)
-{
-	return heapAllocate(size);
-}
-
-void operator delete(void* m)
-{
-	heapFree(m);
-}
-
-void operator delete[](void* m)
-{
-	heapFree(m);
-}
-
 bool _heapExpand()
 {
 	if(heapEnd + G_KERNEL_HEAP_EXPAND_STEP > G_KERNEL_HEAP_END)
@@ -154,4 +134,4 @@ bool _heapExpand()
 	logDebug("%! expanded to end %h (%ikb in use)", "kernheap", heapEnd, heapAmountInUse / 1024);
 
 	return true;
-}
+}

kernel/src/kernel/runtime/itanium_cxx_abi_support.cpp

@@ -0,0 +1,64 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                                                                           *
+ *  Ghost, a micro-kernel based operating system for the x86 architecture    *
+ *  Copyright (C) 2015, Max Schlüssel <[email protected]>                     *
+ *                                                                           *
+ *  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/memory/heap.hpp"
+#include "shared/panic.hpp"
+
+// The functions in this file are implemented as defined in the Itanium C++ ABI
+// standard. These functions are required by GCC for special cases, see the
+// individual documentation for details.
+
+namespace std
+{
+	[[noreturn]] void __throw_bad_function_call()
+	{
+		panic("bad function call");
+	}
+}
+
+void* operator new(size_t size, void* ptr) noexcept
+{
+	return ptr;
+}
+
+void* operator new[](size_t size, void* ptr) noexcept
+{
+	return ptr;
+}
+
+void* operator new(size_t size)
+{
+	return heapAllocate(size);
+}
+
+void* operator new[](size_t size)
+{
+	return heapAllocate(size);
+}
+
+void operator delete(void* m)
+{
+	heapFree(m);
+}
+
+void operator delete[](void* m)
+{
+	heapFree(m);
+}

kernel/src/kernel/runtime/itanium_cxx_abi_support.hpp

@@ -0,0 +1,31 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+*                                                                           *
+ *  Ghost, a micro-kernel based operating system for the x86 architecture    *
+ *  Copyright (C) 2015, Max Schlüssel <[email protected]>                     *
+ *                                                                           *
+ *  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/>.    *
+ *                                                                           *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef __ITANIUM_CXX_ABI_SUPPORT__
+#define __ITANIUM_CXX_ABI_SUPPORT__
+
+#include <bits/std_function.h>
+
+// Must be defined because we use -ffreestanding which causes these to not be
+// available when trying to use std::function
+void* operator new(size_t size, void* ptr) noexcept;
+void* operator new[](size_t size, void* ptr) noexcept;
+
+#endif

kernel/src/kernel/tasking/tasking.cpp

@@ -513,17 +513,11 @@ g_spawn_result taskingSpawn(g_fd fd, g_security_level securityLevel)
 	taskingStateReset(child, (g_address) &taskingSpawnEntry, G_SECURITY_LEVEL_KERNEL);
 
 	// Start thread & wait for spawn to finish
-	INTERRUPTS_PAUSE;
-	child->spawnFinished = false;
-
-	mutexAcquire(&parent->lock);
-	parent->status = G_TASK_STATUS_WAITING;
-	parent->waitsFor = "spawn";
-	mutexRelease(&parent->lock);
-
-	taskingAssignBalanced(child);
-	taskingYield();
-	INTERRUPTS_RESUME;
+	taskingWait(parent, __func__, [child]()
+	{
+		child->spawnFinished = false;
+		taskingAssignBalanced(child);
+	});
 
 	// Take result
 	res.status = res.process->spawnArgs->status;
@@ -569,16 +563,12 @@ void taskingFinalizeSpawn(g_task* task)
 	task->securityLevel = process->spawnArgs->securityLevel;
 	taskingStateReset(task, process->spawnArgs->entry, task->securityLevel);
 
-	task->spawnFinished = true;
-	auto parent = taskingGetById(process->spawnArgs->parent);
-	taskingWake(parent);
-
-	mutexAcquire(&task->lock);
-	task->status = G_TASK_STATUS_WAITING;
-	task->waitsFor = "wake-after-spawn";
-	mutexRelease(&task->lock);
-	taskingYield();
-	INTERRUPTS_RESUME;
+	taskingWait(task, __func__, [task, process]()
+	{
+		task->spawnFinished = true;
+		auto parent = taskingGetById(process->spawnArgs->parent);
+		taskingWake(parent);
+	});
 }
 
 void taskingWaitForExit(g_tid joinedTid, g_tid waiter)
@@ -602,3 +592,16 @@ void taskingWake(g_task* task)
 		mutexRelease(&task->lock);
 	}
 }
+
+void taskingWait(g_task* task, const char* debugName, const std::function<void ()>& beforeYield)
+{
+	INTERRUPTS_PAUSE;
+	mutexAcquire(&task->lock);
+	task->status = G_TASK_STATUS_WAITING;
+	task->waitsFor = debugName;
+	mutexRelease(&task->lock);
+	if(beforeYield)
+		beforeYield();
+	taskingYield();
+	INTERRUPTS_RESUME;
+}