Avoid nested locking where possible; add scheduler preference to fix g_yield_t

maxdev1 · maxdev1 · commit 516b82a0dd34 · 2025-02-28T21:33:18.000+01:00
Holding locks and calling other code can lead to the situation where processor 0 tries to lock ABBA and processor 1 tries BAAB, which causes a deadlock when the simultaneously reach the second lock. This pattern should avoid this.
diff --git a/kernel/inc/build_config.hpp b/kernel/inc/build_config.hpp
@@ -48,7 +48,7 @@
 // version
 #define G_VERSION_MAJOR 0
 #define G_VERSION_MINOR 20
-#define G_VERSION_PATCH 0
+#define G_VERSION_PATCH 1
 
 #define G_LOADER_VERSION_MAJOR 1
 #define G_LOADER_VERSION_MINOR 1
diff --git a/kernel/inc/shared/system/spinlock.hpp b/kernel/inc/shared/system/spinlock.hpp
@@ -21,12 +21,13 @@
 #ifndef __SYSTEM_SPINLOCK__
 #define __SYSTEM_SPINLOCK__
 
-typedef volatile int g_spinlock;
+typedef int g_spinlock;
 
-#define G_SPINLOCK_ACQUIRE(lock)                        \
-	while(!__sync_bool_compare_and_swap(&lock, 0, 1)) \
-		asm volatile("pause");
+#define G_SPINLOCK_ACQUIRE(lock)                          \
+      while(!__sync_bool_compare_and_swap(&lock, 0, 1))   \
+      asm volatile("pause");
 
-#define G_SPINLOCK_RELEASE(lock) lock = 0;
+#define G_SPINLOCK_RELEASE(lock)                          \
+      do { __sync_synchronize(); lock = 0; } while(0)
 
 #endif
diff --git a/kernel/src/kernel/calls/syscall_memory.cpp b/kernel/src/kernel/calls/syscall_memory.cpp
@@ -143,16 +143,16 @@ void syscallShareMemory(g_task* task, g_syscall_share_mem* data)
 
 	g_virtual_address virtualRangeBase = addressRangePoolAllocate(targetProcess->virtualRangePool, pages,
 	                                                              G_PROC_VIRTUAL_RANGE_FLAG_NONE);
+	mutexRelease(&targetProcess->lock);
+
 	if(virtualRangeBase == 0)
 	{
 		logInfo(
 				"%! task %i was unable to share memory area %h of size %h with task %i because there was no free virtual range",
 				"syscall",
 				task->id, memory, pages * G_PAGE_SIZE, targetProcess->main->id);
-		mutexRelease(&targetProcess->lock);
 		return;
 	}
-	mutexRelease(&targetProcess->lock);
 
 	for(uint32_t i = 0; i < pages; i++)
 	{
diff --git a/kernel/src/kernel/calls/syscall_messaging.cpp b/kernel/src/kernel/calls/syscall_messaging.cpp
@@ -29,12 +29,14 @@ void syscallMessageSend(g_task* task, g_syscall_send_message* data)
 	      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";
-		messageWaitForSend(task->id, data->receiver);
 		mutexRelease(&task->lock);
+		messageWaitForSend(task->id, data->receiver);
 		taskingYield();
+		INTERRUPTS_RESUME;
 	}
 	messageUnwaitForSend(task->id, data->receiver);
 }
@@ -55,11 +57,13 @@ void syscallMessageReceive(g_task* task, g_syscall_receive_message* data)
 		//	break;
 		// }
 
+		INTERRUPTS_PAUSE;
 		mutexAcquire(&task->lock);
 		task->status = G_TASK_STATUS_WAITING;
 		task->waitsFor = "message-recv";
 		mutexRelease(&task->lock);
 		taskingYield();
+		INTERRUPTS_RESUME;
 	}
 }
 
diff --git a/kernel/src/kernel/calls/syscall_tasking.cpp b/kernel/src/kernel/calls/syscall_tasking.cpp
@@ -32,12 +32,14 @@
 
 void syscallSleep(g_task* task, g_syscall_sleep* data)
 {
+	INTERRUPTS_PAUSE;
 	mutexAcquire(&task->lock);
 	task->status = G_TASK_STATUS_WAITING;
 	task->waitsFor = "sleeps";
-	clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);
 	mutexRelease(&task->lock);
+	clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);
 	taskingYield();
+	INTERRUPTS_RESUME;
 }
 
 void syscallYield(g_task* task, g_syscall_yield* data)
@@ -85,12 +87,14 @@ 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 = "sleeps";
-	taskingWaitForExit(data->taskId, task->id);
 	mutexRelease(&task->lock);
+	taskingWaitForExit(data->taskId, task->id);
 	taskingYield();
+	INTERRUPTS_RESUME;
 }
 
 void syscallSpawn(g_task* task, g_syscall_spawn* data)
@@ -141,12 +145,14 @@ void syscallKill(g_task* task, g_syscall_kill* data)
 	g_task* target = taskingGetById(data->pid);
 	if(target)
 	{
+		INTERRUPTS_PAUSE;
 		mutexAcquire(&target->lock);
 		data->status = G_KILL_STATUS_SUCCESSFUL;
 		target->process->main->status = G_TASK_STATUS_DEAD;
-		waitQueueWake(&target->waitersJoin);
 		mutexRelease(&target->lock);
+		waitQueueWake(&target->waitersJoin);
 		taskingYield();
+		INTERRUPTS_RESUME;
 	}
 	else
 	{
@@ -156,8 +162,6 @@ void syscallKill(g_task* task, g_syscall_kill* data)
 
 void syscallCreateTask(g_task* task, g_syscall_create_task* data)
 {
-	 mutexAcquire(&task->process->lock);
-
 	g_task* newTask = taskingCreateTask((g_virtual_address) data->initialEntry, task->process,
 	                                    task->process->main->securityLevel);
 	if(newTask)
@@ -172,8 +176,6 @@ void syscallCreateTask(g_task* task, g_syscall_create_task* data)
 	{
 		data->status = G_CREATE_TASK_STATUS_FAILED;
 	}
-
-	mutexRelease(&task->process->lock);
 }
 
 void syscallGetTaskEntry(g_task* task, g_syscall_get_task_entry* data)
diff --git a/kernel/src/kernel/filesystem/filesystem.cpp b/kernel/src/kernel/filesystem/filesystem.cpp
@@ -411,12 +411,14 @@ g_fs_read_status filesystemRead(g_task* task, g_fd fd, uint8_t* buffer, uint64_t
 			panic("%! task %i tried to wait for file %i but delegate didn't provide wait-for-read implementation",
 			      "filesytem", task->id, node->id);
 
+		INTERRUPTS_PAUSE;
 		mutexAcquire(&task->lock);
 		task->status = G_TASK_STATUS_WAITING;
 		task->waitsFor = "read";
-		delegate->waitForRead(task->id, node);
 		mutexRelease(&task->lock);
+		delegate->waitForRead(task->id, node);
 		taskingYield();
+		INTERRUPTS_RESUME;
 
 		// TODO
 		if(node->nonInterruptible && clockHasTimedOut(task->id))
@@ -503,12 +505,14 @@ g_fs_write_status filesystemWrite(g_task* task, g_fd fd, uint8_t* buffer, uint64
 			panic("%! task %i tried to wait for file %i but delegate didn't provide wait-for-write implementation",
 			      "filesytem", task->id, node->id);
 
+		INTERRUPTS_PAUSE;
 		mutexAcquire(&task->lock);
 		task->status = G_TASK_STATUS_WAITING;
 		task->waitsFor = "write";
-		delegate->waitForWrite(task->id, node);
 		mutexRelease(&task->lock);
+		delegate->waitForWrite(task->id, node);
 		taskingYield();
+		INTERRUPTS_RESUME;
 	}
 	if(wrote > 0)
 	{
diff --git a/kernel/src/kernel/ipc/message.cpp b/kernel/src/kernel/ipc/message.cpp
@@ -161,17 +161,13 @@ void messageTaskRemoved(g_tid task)
 void messageWaitForSend(g_tid sender, g_tid receiver)
 {
 	g_message_queue* queue = _messageGetQueue(receiver);
-	mutexAcquire(&queue->lock);
 	waitQueueAdd(&queue->waitersSend, sender);
-	mutexRelease(&queue->lock);
 }
 
 void messageUnwaitForSend(g_tid sender, g_tid receiver)
 {
 	g_message_queue* queue = _messageGetQueue(receiver);
-	mutexAcquire(&queue->lock);
 	waitQueueRemove(&queue->waitersSend, sender);
-	mutexRelease(&queue->lock);
 }
 
 void _messageWakeWaitingReceiver(g_message_queue* queue)
diff --git a/kernel/src/kernel/ipc/pipes.cpp b/kernel/src/kernel/ipc/pipes.cpp
@@ -264,9 +264,7 @@ void pipeWaitForRead(g_tid task, g_fs_phys_id pipeId)
 	if(!pipe)
 		return;
 
-	mutexAcquire(&pipe->lock);
 	waitQueueAdd(&pipe->waitersRead, task);
-	mutexRelease(&pipe->lock);
 }
 
 void pipeWaitForWrite(g_tid task, g_fs_phys_id pipeId)
@@ -275,7 +273,5 @@ void pipeWaitForWrite(g_tid task, g_fs_phys_id pipeId)
 	if(!pipe)
 		return;
 
-	mutexAcquire(&pipe->lock);
 	waitQueueAdd(&pipe->waitersWrite, task);
-	mutexRelease(&pipe->lock);
 }
diff --git a/kernel/src/kernel/system/interrupts/interrupts.cpp b/kernel/src/kernel/system/interrupts/interrupts.cpp
@@ -91,7 +91,7 @@ extern "C" volatile g_processor_state* _interruptHandler(volatile g_processor_st
 		if(irq == 0) // Timer
 		{
 			clockUpdate();
-			taskingSchedule();
+			taskingSchedule(true);
 		}
 		else
 		{
diff --git a/kernel/src/kernel/system/processor/processor.cpp b/kernel/src/kernel/system/processor/processor.cpp
@@ -313,3 +313,8 @@ const uint8_t* processorGetInitialFpuState()
 {
 	return _processorGetCurrent()->fpu.initialState;
 }
+
+bool processorIsBsp()
+{
+	return processorGetCurrentId() == 0;
+}
diff --git a/kernel/src/kernel/system/processor/processor.hpp b/kernel/src/kernel/system/processor/processor.hpp
@@ -258,4 +258,9 @@ bool processorHasFeatureReady(g_cpuid_standard_edx_feature feature);
  */
 const uint8_t* processorGetInitialFpuState();
 
+/**
+ * @return whether this code is running on the BSP
+ */
+bool processorIsBsp();
+
 #endif
diff --git a/kernel/src/kernel/tasking/cleanup.cpp b/kernel/src/kernel/tasking/cleanup.cpp
@@ -73,11 +73,13 @@ void taskingCleanupThread()
 		}
 
 		// Sleep for some time
+		INTERRUPTS_PAUSE;
 		mutexAcquire(&self->lock);
 		self->status = G_TASK_STATUS_WAITING;
 		self->waitsFor = "cleanup-sleep";
-		clockWaitForTime(self->id, clockGetLocal()->time + 3000);
 		mutexRelease(&self->lock);
+		clockWaitForTime(self->id, clockGetLocal()->time + 3000);
 		taskingYield();
+		INTERRUPTS_RESUME;
 	}
 }
diff --git a/kernel/src/kernel/tasking/scheduler/scheduler_round_robin.cpp b/kernel/src/kernel/tasking/scheduler/scheduler_round_robin.cpp
@@ -50,9 +50,8 @@ g_schedule_entry* schedulerGetNextTask(g_tasking_local* local)
 		return entry;
 	}
 
-	// // Check if there is a global "preferred task" to do next
-	// TODO: This causes rare deadlocks...
-	if(false && preferredTask != G_TID_NONE)
+	// Check if there is a global "preferred task" to do next
+	if(preferredTask != G_TID_NONE)
 	{
 		while(entry)
 		{
diff --git a/kernel/src/kernel/tasking/tasking.cpp b/kernel/src/kernel/tasking/tasking.cpp
@@ -308,7 +308,12 @@ void taskingRestoreState(g_task* task)
 		processorRestoreFpuState(task->fpu.state);
 }
 
-void taskingSchedule() { schedulerSchedule(taskingGetLocal()); }
+void taskingSchedule(bool resetPreference)
+{
+	if(resetPreference && processorIsBsp())
+		schedulerPrefer(G_TID_NONE);
+	schedulerSchedule(taskingGetLocal());
+}
 
 g_process* taskingCreateProcess(g_security_level securityLevel)
 {
@@ -439,7 +444,7 @@ void taskingDestroyTask(g_task* task)
 
 void _taskingInitializeTask(g_task* task, g_process* process, g_security_level level)
 {
-	if(process->main == 0)
+	if(process->main == nullptr)
 		task->id = process->id;
 	else
 		task->id = taskingGetNextId();
@@ -510,17 +515,19 @@ g_spawn_result taskingSpawn(g_fd fd, g_security_level securityLevel)
 	mutexAcquire(&caller->lock);
 	caller->status = G_TASK_STATUS_WAITING;
 	caller->waitsFor = "spawn";
+	mutexRelease(&caller->lock);
 	waitQueueAdd(&res.process->waitersSpawn, caller->id);
 	taskingAssignBalanced(newTask);
-	mutexRelease(&caller->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;
 	}
 
 	// Take result
@@ -566,12 +573,14 @@ void taskingFinalizeSpawn(g_task* task)
 	taskingStateReset(task, process->spawnArgs->entry, task->securityLevel);
 	waitQueueWake(&process->waitersSpawn);
 
+	INTERRUPTS_PAUSE;
 	mutexAcquire(&task->lock);
 	task->status = G_TASK_STATUS_WAITING;
 	task->waitsFor = "wake-after-spawn";
 	task->spawnFinished = true;
 	mutexRelease(&task->lock);
 	taskingYield();
+	INTERRUPTS_RESUME;
 }
 
 void taskingWaitForExit(g_tid joinedTid, g_tid waiter)
diff --git a/kernel/src/kernel/tasking/tasking.hpp b/kernel/src/kernel/tasking/tasking.hpp
diff --git a/kernel/src/kernel/tasking/user_mutex.cpp b/kernel/src/kernel/tasking/user_mutex.cpp

Original file line number	Diff line number	Diff line change
`@@ -143,16 +143,16 @@ void syscallShareMemory(g_task* task, g_syscall_share_mem* data)`
`143`	`143`
`144`	`144`	`g_virtual_address virtualRangeBase = addressRangePoolAllocate(targetProcess->virtualRangePool, pages,`
`145`	`145`	`G_PROC_VIRTUAL_RANGE_FLAG_NONE);`
	`146`	`+ mutexRelease(&targetProcess->lock);`
	`147`	`+`
`146`	`148`	`if(virtualRangeBase == 0)`
`147`	`149`	`{`
`148`	`150`	`logInfo(`
`149`	`151`	`"%! task %i was unable to share memory area %h of size %h with task %i because there was no free virtual range",`
`150`	`152`	`"syscall",`
`151`	`153`	`task->id, memory, pages * G_PAGE_SIZE, targetProcess->main->id);`
`152`		`- mutexRelease(&targetProcess->lock);`
`153`	`154`	`return;`
`154`	`155`	`}`
`155`		`- mutexRelease(&targetProcess->lock);`
`156`	`156`
`157`	`157`	`for(uint32_t i = 0; i < pages; i++)`
`158`	`158`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,14 @@ void syscallMessageSend(g_task* task, g_syscall_send_message* data)`
`29`	`29`	`G_MESSAGE_SEND_STATUS_QUEUE_FULL &&`
`30`	`30`	`data->mode == G_MESSAGE_SEND_MODE_BLOCKING)`
`31`	`31`	`{`
	`32`	`+ INTERRUPTS_PAUSE;`
`32`	`33`	`mutexAcquire(&task->lock);`
`33`	`34`	`task->status = G_TASK_STATUS_WAITING;`
`34`	`35`	`task->waitsFor = "message-send";`
`35`		`- messageWaitForSend(task->id, data->receiver);`
`36`	`36`	`mutexRelease(&task->lock);`
	`37`	`+ messageWaitForSend(task->id, data->receiver);`
`37`	`38`	`taskingYield();`
	`39`	`+ INTERRUPTS_RESUME;`
`38`	`40`	`}`
`39`	`41`	`messageUnwaitForSend(task->id, data->receiver);`
`40`	`42`	`}`
`@@ -55,11 +57,13 @@ void syscallMessageReceive(g_task* task, g_syscall_receive_message* data)`
`55`	`57`	`// break;`
`56`	`58`	`// }`
`57`	`59`
	`60`	`+ INTERRUPTS_PAUSE;`
`58`	`61`	`mutexAcquire(&task->lock);`
`59`	`62`	`task->status = G_TASK_STATUS_WAITING;`
`60`	`63`	`task->waitsFor = "message-recv";`
`61`	`64`	`mutexRelease(&task->lock);`
`62`	`65`	`taskingYield();`
	`66`	`+ INTERRUPTS_RESUME;`
`63`	`67`	`}`
`64`	`68`	`}`
`65`	`69`
Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,14 @@`
`32`	`32`
`33`	`33`	`void syscallSleep(g_task* task, g_syscall_sleep* data)`
`34`	`34`	`{`
	`35`	`+ INTERRUPTS_PAUSE;`
`35`	`36`	`mutexAcquire(&task->lock);`
`36`	`37`	`task->status = G_TASK_STATUS_WAITING;`
`37`	`38`	`task->waitsFor = "sleeps";`
`38`		`- clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);`
`39`	`39`	`mutexRelease(&task->lock);`
	`40`	`+ clockWaitForTime(task->id, clockGetLocal()->time + data->milliseconds);`
`40`	`41`	`taskingYield();`
	`42`	`+ INTERRUPTS_RESUME;`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`void syscallYield(g_task* task, g_syscall_yield* data)`
`@@ -85,12 +87,14 @@ void syscallGetProcessIdForTaskId(g_task* task, g_syscall_get_pid_for_tid* data)`
`85`	`87`
`86`	`88`	`void syscallJoin(g_task* task, g_syscall_join* data)`
`87`	`89`	`{`
	`90`	`+ INTERRUPTS_PAUSE;`
`88`	`91`	`mutexAcquire(&task->lock);`
`89`	`92`	`task->status = G_TASK_STATUS_WAITING;`
`90`	`93`	`task->waitsFor = "sleeps";`
`91`		`- taskingWaitForExit(data->taskId, task->id);`
`92`	`94`	`mutexRelease(&task->lock);`
	`95`	`+ taskingWaitForExit(data->taskId, task->id);`
`93`	`96`	`taskingYield();`
	`97`	`+ INTERRUPTS_RESUME;`
`94`	`98`	`}`
`95`	`99`
`96`	`100`	`void syscallSpawn(g_task* task, g_syscall_spawn* data)`
`@@ -141,12 +145,14 @@ void syscallKill(g_task* task, g_syscall_kill* data)`
`141`	`145`	`g_task* target = taskingGetById(data->pid);`
`142`	`146`	`if(target)`
`143`	`147`	`{`
	`148`	`+ INTERRUPTS_PAUSE;`
`144`	`149`	`mutexAcquire(&target->lock);`
`145`	`150`	`data->status = G_KILL_STATUS_SUCCESSFUL;`
`146`	`151`	`target->process->main->status = G_TASK_STATUS_DEAD;`
`147`		`- waitQueueWake(&target->waitersJoin);`
`148`	`152`	`mutexRelease(&target->lock);`
	`153`	`+ waitQueueWake(&target->waitersJoin);`
`149`	`154`	`taskingYield();`
	`155`	`+ INTERRUPTS_RESUME;`
`150`	`156`	`}`
`151`	`157`	`else`
`152`	`158`	`{`
`@@ -156,8 +162,6 @@ void syscallKill(g_task* task, g_syscall_kill* data)`
`156`	`162`
`157`	`163`	`void syscallCreateTask(g_task* task, g_syscall_create_task* data)`
`158`	`164`	`{`
`159`		`- mutexAcquire(&task->process->lock);`
`160`		`-`
`161`	`165`	`g_task* newTask = taskingCreateTask((g_virtual_address) data->initialEntry, task->process,`
`162`	`166`	`task->process->main->securityLevel);`
`163`	`167`	`if(newTask)`
`@@ -172,8 +176,6 @@ void syscallCreateTask(g_task* task, g_syscall_create_task* data)`
`172`	`176`	`{`
`173`	`177`	`data->status = G_CREATE_TASK_STATUS_FAILED;`
`174`	`178`	`}`
`175`		`-`
`176`		`- mutexRelease(&task->process->lock);`
`177`	`179`	`}`
`178`	`180`
`179`	`181`	`void syscallGetTaskEntry(g_task* task, g_syscall_get_task_entry* data)`
Original file line number	Diff line number	Diff line change
`@@ -161,17 +161,13 @@ void messageTaskRemoved(g_tid task)`
`161`	`161`	`void messageWaitForSend(g_tid sender, g_tid receiver)`
`162`	`162`	`{`
`163`	`163`	`g_message_queue* queue = _messageGetQueue(receiver);`
`164`		`- mutexAcquire(&queue->lock);`
`165`	`164`	`waitQueueAdd(&queue->waitersSend, sender);`
`166`		`- mutexRelease(&queue->lock);`
`167`	`165`	`}`
`168`	`166`
`169`	`167`	`void messageUnwaitForSend(g_tid sender, g_tid receiver)`
`170`	`168`	`{`
`171`	`169`	`g_message_queue* queue = _messageGetQueue(receiver);`
`172`		`- mutexAcquire(&queue->lock);`
`173`	`170`	`waitQueueRemove(&queue->waitersSend, sender);`
`174`		`- mutexRelease(&queue->lock);`
`175`	`171`	`}`
`176`	`172`
`177`	`173`	`void _messageWakeWaitingReceiver(g_message_queue* queue)`
Original file line number	Diff line number	Diff line change
`@@ -264,9 +264,7 @@ void pipeWaitForRead(g_tid task, g_fs_phys_id pipeId)`
`264`	`264`	`if(!pipe)`
`265`	`265`	`return;`
`266`	`266`
`267`		`- mutexAcquire(&pipe->lock);`
`268`	`267`	`waitQueueAdd(&pipe->waitersRead, task);`
`269`		`- mutexRelease(&pipe->lock);`
`270`	`268`	`}`
`271`	`269`
`272`	`270`	`void pipeWaitForWrite(g_tid task, g_fs_phys_id pipeId)`
`@@ -275,7 +273,5 @@ void pipeWaitForWrite(g_tid task, g_fs_phys_id pipeId)`
`275`	`273`	`if(!pipe)`
`276`	`274`	`return;`
`277`	`275`
`278`		`- mutexAcquire(&pipe->lock);`
`279`	`276`	`waitQueueAdd(&pipe->waitersWrite, task);`
`280`		`- mutexRelease(&pipe->lock);`
`281`	`277`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ extern "C" volatile g_processor_state* _interruptHandler(volatile g_processor_st`
`91`	`91`	`if(irq == 0) // Timer`
`92`	`92`	`{`
`93`	`93`	`clockUpdate();`
`94`		`- taskingSchedule();`
	`94`	`+ taskingSchedule(true);`
`95`	`95`	`}`
`96`	`96`	`else`
`97`	`97`	`{`
Original file line number	Diff line number	Diff line change
`@@ -313,3 +313,8 @@ const uint8_t* processorGetInitialFpuState()`
`313`	`313`	`{`
`314`	`314`	`return _processorGetCurrent()->fpu.initialState;`
`315`	`315`	`}`
	`316`	`+`
	`317`	`+bool processorIsBsp()`
	`318`	`+{`
	`319`	`+ return processorGetCurrentId() == 0;`
	`320`	`+}`