[Kernel - Rust] Add a spinlock API

Author: codyd51

programs/subprojects/task_viewer/task_viewer.c

@@ -28,6 +28,7 @@ typedef struct task_info {
     uint64_t user_mode_rip;
 	bool has_amc_service;
 	uint64_t pending_amc_messages;
+    // TODO(PT): Add CPU ID here
 } task_info_t;
 
 typedef struct task_viewer_get_task_info_response {
@@ -210,7 +211,7 @@ static void _layout_tasks() {
 		_draw_string(&view->view, buf, cursor, font_size, color_black(), color_white(), 0, 0);
 
 		// Draw AMC service info, if available, else draw a blank space
-		cursor = point_make(4, cursor.y + (font_size.height * 1.5));
+		cursor = point_make(4, cursor.y + (font_size.height * 1));
 		memset(buf, 0, sizeof(buf));
 		if (task->has_amc_service) {
 			snprintf(buf, sizeof(buf), "  Pending messages: %d", task->pending_amc_messages);

rust_kernel_libs/acpi/src/lib.rs

@@ -39,6 +39,7 @@ mod apic;
 mod interrupts;
 mod scheduler;
 mod smp;
+mod spinlocks;
 mod structs;
 mod utils;
 

rust_kernel_libs/acpi/src/spinlocks.rs

@@ -0,0 +1,42 @@
+use alloc::collections::BTreeMap;
+use alloc::vec::Vec;
+use core::hint;
+use core::sync::atomic::{AtomicBool, Ordering};
+use ffi_bindings::Spinlock;
+use lazy_static::lazy_static;
+use spin::Mutex;
+
+lazy_static! {
+    // TODO(PT): Eventually, we could replace the C representation with an FFI-safe Rust-managed version entirely
+    static ref SPINLOCKS: spin::Mutex<BTreeMap<&'static Spinlock, AtomicBool>> = Mutex::new(BTreeMap::new());
+}
+
+unsafe fn track_lock_if_necessary(spinlock: &'static Spinlock) {
+    let mut lock_ptrs_to_locks = SPINLOCKS.lock();
+    if !lock_ptrs_to_locks.contains_key(&spinlock) {
+        lock_ptrs_to_locks.insert(spinlock, AtomicBool::new(false));
+    }
+}
+
+#[no_mangle]
+pub unsafe fn spinlock_acquire_spin(spinlock_raw: *const Spinlock) {
+    let spinlock: &'static Spinlock = &*spinlock_raw;
+    track_lock_if_necessary(spinlock);
+    let spinlocks = SPINLOCKS.lock();
+    let is_locked = spinlocks.get(spinlock).unwrap();
+
+    // Keep spinning while the previous value was "already locked"
+    while is_locked.swap(true, Ordering::Acquire) == true {
+        hint::spin_loop();
+    }
+    // The lock is now ours
+}
+
+#[no_mangle]
+pub unsafe fn spinlock_release_spin(spinlock_raw: *const Spinlock) {
+    let spinlock: &'static Spinlock = &*spinlock_raw;
+    // TODO(PT): Is SPINLOCKS.lock() itself going to act as a mutex?
+    let spinlocks = SPINLOCKS.lock();
+    let is_locked = spinlocks.get(spinlock).unwrap();
+    is_locked.store(false, Ordering::Release);
+}