Fix issue with wake on spawn, improve overall wake-handling

Author: maxdev1

kernel/src/kernel/ipc/message.cpp

@@ -171,13 +171,7 @@ void messageUnwaitForSend(g_tid sender, g_tid receiver)
 void _messageWakeWaitingReceiver(g_message_queue* queue)
 {
 	g_task* task = taskingGetById(queue->task);
-	if(task)
-	{
-		mutexAcquire(&task->lock);
-		if(task->status == G_TASK_STATUS_WAITING)
-			task->status = G_TASK_STATUS_RUNNING;
-		mutexRelease(&task->lock);
-	}
+	taskingWake(task);
 }
 
 void _messageRemoveFromQueue(g_message_queue* queue, g_message_header* message)

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

@@ -60,11 +60,7 @@ void requestsHandle(g_task* currentTask, uint8_t irq)
 	if(!handlerTask)
 		return;
 
-	mutexAcquire(&handlerTask->lock);
-	if(handlerTask->status == G_TASK_STATUS_WAITING)
-		handlerTask->status = G_TASK_STATUS_RUNNING;
-	mutexRelease(&handlerTask->lock);
-
+	taskingWake(handlerTask);
 	taskingSetCurrent(handlerTask);
 
 	// Once the handler has finished, let the scheduler go back to interrupted task

kernel/src/kernel/tasking/clock.cpp

@@ -103,12 +103,7 @@ void clockWakeWaiters(g_clock_local* local)
 	while(local->waiters && local->time >= local->waiters->wakeTime)
 	{
 		g_task* task = taskingGetById(local->waiters->task);
-		if(task)
-		{
-			mutexAcquire(&task->lock);
-			task->status = G_TASK_STATUS_RUNNING;
-			mutexRelease(&task->lock);
-		}
+		taskingWake(task);
 
 		auto next = local->waiters->next;
 		heapFree(local->waiters);

kernel/src/kernel/tasking/task.hpp

@@ -182,6 +182,7 @@ struct g_task_entry
 
 struct g_process_spawn_arguments
 {
+    g_tid parent;
     g_fd fd;
     g_security_level securityLevel;
     g_address entry;
@@ -268,11 +269,6 @@ struct g_process
      */
     g_process_spawn_arguments* spawnArgs;
 
-    /**
-     * List of tasks that wait for the result of spawning.
-     */
-    g_wait_queue waitersSpawn;
-
     /**
      * List of on-demand file-to-memory mappings.
      */

kernel/src/kernel/tasking/tasking.cpp

@@ -370,7 +370,10 @@ void taskingDestroyProcess(g_process* process)
 
 g_task* taskingCreateTask(g_virtual_address eip, g_process* process, g_security_level level)
 {
-	g_task* task = (g_task*) heapAllocateClear(sizeof(g_task));
+	auto task = (g_task*) heapAllocateClear(sizeof(g_task));
+	if(!task)
+		return nullptr;
+
 	_taskingInitializeTask(task, process, level);
 	task->type = G_TASK_TYPE_DEFAULT;
 
@@ -479,13 +482,13 @@ void taskingProcessKillAllTasks(g_pid pid)
 
 g_spawn_result taskingSpawn(g_fd fd, g_security_level securityLevel)
 {
-	g_task* caller = taskingGetCurrentTask();
+	g_task* parent = taskingGetCurrentTask();
 
 	// Create target process & task
-	g_spawn_result res;
+	g_spawn_result res{};
 	res.process = taskingCreateProcess(securityLevel);
-	g_task* newTask = taskingCreateTask(0, res.process, securityLevel);
-	if(!newTask)
+	g_task* child = taskingCreateTask(0, res.process, securityLevel);
+	if(!child)
 	{
 		logInfo("%! failed to create main thread to spawn binary", "elf");
 		res.status = G_SPAWN_STATUS_TASKING_ERROR;
@@ -494,42 +497,35 @@ g_spawn_result taskingSpawn(g_fd fd, g_security_level securityLevel)
 
 	// Clone FD to target process
 	g_fd targetFd;
-	auto cloneStat = filesystemProcessCloneDescriptor(caller->process->id, fd, res.process->id, G_FD_NONE, &targetFd);
+	auto cloneStat = filesystemProcessCloneDescriptor(parent->process->id, fd, res.process->id, G_FD_NONE, &targetFd);
 	if(cloneStat != G_FS_CLONEFD_SUCCESSFUL)
 	{
-		logInfo("%! failed to clone executable FD to target process", "elf");
+		logInfo("%! failed to clone binary FD to target process", "elf");
 		res.status = G_SPAWN_STATUS_IO_ERROR;
 		return res;
 	}
 
 	// Provide spawn arguments
 	res.process->spawnArgs = (g_process_spawn_arguments*) heapAllocateClear(sizeof(g_process_spawn_arguments));
+	res.process->spawnArgs->parent = parent->id;
 	res.process->spawnArgs->fd = targetFd;
 	res.process->spawnArgs->securityLevel = securityLevel;
 
 	// Set kernel-level entry
-	taskingStateReset(newTask, (g_address) &taskingSpawnEntry, G_SECURITY_LEVEL_KERNEL);
+	taskingStateReset(child, (g_address) &taskingSpawnEntry, G_SECURITY_LEVEL_KERNEL);
 
 	// Start thread & wait for spawn to finish
-	newTask->spawnFinished = false;
+	INTERRUPTS_PAUSE;
+	child->spawnFinished = false;
 
-	mutexAcquire(&caller->lock);
-	caller->status = G_TASK_STATUS_WAITING;
-	caller->waitsFor = "spawn";
-	mutexRelease(&caller->lock);
-	waitQueueAdd(&res.process->waitersSpawn, caller->id);
-	taskingAssignBalanced(newTask);
+	mutexAcquire(&parent->lock);
+	parent->status = G_TASK_STATUS_WAITING;
+	parent->waitsFor = "spawn";
+	mutexRelease(&parent->lock);
 
-	while(!newTask->spawnFinished)
-	{
-		INTERRUPTS_PAUSE;
-		mutexAcquire(&caller->lock);
-		caller->status = G_TASK_STATUS_WAITING;
-		caller->waitsFor = "spawn-rep";
-		mutexRelease(&caller->lock);
-		taskingYield();
-		INTERRUPTS_RESUME;
-	}
+	taskingAssignBalanced(child);
+	taskingYield();
+	INTERRUPTS_RESUME;
 
 	// Take result
 	res.status = res.process->spawnArgs->status;
@@ -556,7 +552,8 @@ void taskingSpawnEntry()
 	if(loadRes.status != G_SPAWN_STATUS_SUCCESSFUL)
 	{
 		logInfo("%! failed to load binary to current address space", "elf");
-		waitQueueWake(&process->waitersSpawn);
+		auto parent = taskingGetById(process->spawnArgs->parent);
+		taskingWake(parent);
 		taskingExit();
 	}
 
@@ -569,16 +566,18 @@ void taskingSpawnEntry()
 
 void taskingFinalizeSpawn(g_task* task)
 {
+	INTERRUPTS_PAUSE;
 	auto process = task->process;
 	task->securityLevel = process->spawnArgs->securityLevel;
 	taskingStateReset(task, process->spawnArgs->entry, task->securityLevel);
-	waitQueueWake(&process->waitersSpawn);
 
-	INTERRUPTS_PAUSE;
+	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";
-	task->spawnFinished = true;
 	mutexRelease(&task->lock);
 	taskingYield();
 	INTERRUPTS_RESUME;
@@ -594,3 +593,14 @@ void taskingWaitForExit(g_tid joinedTid, g_tid waiter)
 	waitQueueAdd(&task->waitersJoin, waiter);
 	mutexRelease(&task->process->lock);
 }
+
+void taskingWake(g_task* task)
+{
+	if(task)
+	{
+		mutexAcquire(&task->lock);
+		if(task->status == G_TASK_STATUS_WAITING)
+			task->status = G_TASK_STATUS_RUNNING;
+		mutexRelease(&task->lock);
+	}
+}

kernel/src/kernel/tasking/tasking.hpp

@@ -252,4 +252,9 @@ void taskingFinalizeSpawn(g_task* task);
  */
 void taskingWaitForExit(g_tid task, g_tid waiter);
 
+/**
+ * Wakes the task.
+ */
+void taskingWake(g_task* task);
+
 #endif

kernel/src/kernel/tasking/user_mutex.cpp

@@ -255,13 +255,7 @@ void _userMutexWakeWaitingTasks(g_user_mutex_entry* entry)
 	while(waiter)
 	{
 		g_task* wakeTask = taskingGetById(waiter->task);
-		if(wakeTask)
-		{
-			mutexAcquire(&wakeTask->lock);
-			if(wakeTask->status == G_TASK_STATUS_WAITING)
-				wakeTask->status = G_TASK_STATUS_RUNNING;
-			mutexRelease(&wakeTask->lock);
-		}
+		taskingWake(wakeTask);
 
 		auto next = waiter->next;
 		heapFree(waiter);

kernel/src/kernel/utils/wait_queue.cpp

@@ -74,13 +74,7 @@ void waitQueueWake(g_wait_queue* queue)
 	while(waiter)
 	{
 		g_task* task = taskingGetById(waiter->task);
-		if(task)
-		{
-			mutexAcquire(&task->lock);
-			if(task->status == G_TASK_STATUS_WAITING)
-				task->status = G_TASK_STATUS_RUNNING;
-			mutexRelease(&task->lock);
-		}
+		taskingWake(task);
 
 		auto next = waiter->next;
 		heapFree(waiter);