sync: move rest of kernel to use oro-sync instead of spin

Cargo.toml

@@ -54,7 +54,6 @@ oro-sync.path = "oro-sync"
 limine = "0.2.0"
 uart_16550 = "0.3.0"
 volatile-register = "0.2.2"
-spin = { version = "0.9.8", features = ["ticket_mutex", "fair_mutex"] }
 
 bindgen = { git = "https://github.com/oro-os/dep.rust-bindgen.git" }
 syn = { version = "2.0.60", features = ["full", "printing"] }

oro-arch-aarch64/Cargo.toml

@@ -32,8 +32,7 @@ oro-debug.workspace = true
 oro-dtb.workspace = true
 oro-type.workspace = true
 oro-dbgutil.workspace = true
-
-spin.workspace = true
+oro-sync.workspace = true
 
 [lints]
 workspace = true

oro-arch-aarch64/src/boot/mod.rs

@@ -11,6 +11,7 @@ mod secondary;
 use oro_debug::dbg;
 #[cfg(debug_assertions)]
 use oro_mem::phys::{Phys, PhysAddr};
+use oro_sync::Lock;
 
 /// The number of pages to allocate for the secondary core stacks.
 // TODO(qix-): Make this configurable.

oro-arch-aarch64/src/init.rs

@@ -4,7 +4,7 @@
 use core::mem::MaybeUninit;
 
 use oro_kernel::KernelState;
-use spin::mutex::fair::FairMutex;
+use oro_sync::TicketMutex;
 
 /// The global kernel state. Initialized once during boot
 /// and re-used across all cores.
@@ -34,7 +34,7 @@ pub unsafe fn initialize_primary(pfa: crate::Pfa) {
 
 	// SAFETY(qix-): We know what we're doing here.
 	#[expect(static_mut_refs)]
-	KernelState::init(&mut KERNEL_STATE, FairMutex::new(pfa))
+	KernelState::init(&mut KERNEL_STATE, TicketMutex::new(pfa))
 		.expect("failed to create global kernel state");
 }
 

oro-arch-x86_64/Cargo.toml

@@ -32,8 +32,7 @@ oro-debug.workspace = true
 oro-dbgutil.workspace = true
 oro-acpi.workspace = true
 oro-id.workspace = true
-
-spin.workspace = true
+oro-sync.workspace = true
 
 [lints]
 workspace = true

oro-arch-x86_64/src/boot/mod.rs

@@ -14,6 +14,7 @@ use oro_mem::{
 	mapper::AddressSpace,
 	phys::{Phys, PhysAddr},
 };
+use oro_sync::Lock;
 
 use crate::mem::address_space::AddressSpaceLayout;
 

oro-arch-x86_64/src/init.rs

@@ -11,7 +11,7 @@ use oro_mem::{
 	pfa::alloc::Alloc,
 	phys::{Phys, PhysAddr},
 };
-use spin::mutex::fair::FairMutex;
+use oro_sync::{Lock, TicketMutex};
 
 use crate::{
 	gdt::{Gdt, SysEntry},
@@ -52,7 +52,7 @@ pub unsafe fn initialize_primary(pfa: crate::Pfa) {
 
 	// SAFETY(qix-): We know what we're doing here.
 	#[expect(static_mut_refs)]
-	KernelState::init(&mut KERNEL_STATE, FairMutex::new(pfa))
+	KernelState::init(&mut KERNEL_STATE, TicketMutex::new(pfa))
 		.expect("failed to create global kernel state");
 
 	#[expect(static_mut_refs)]
@@ -107,7 +107,7 @@ pub unsafe fn initialize_primary(pfa: crate::Pfa) {
 				.expect("failed to create root ring module");
 
 			let entry_point = {
-				let module_lock = module_handle.try_lock().expect("failed to lock module");
+				let module_lock = module_handle.lock();
 
 				let mapper = module_lock.mapper();
 
@@ -149,7 +149,7 @@ pub unsafe fn initialize_primary(pfa: crate::Pfa) {
 						segment.target_size()
 					);
 
-					let mut pfa = state.pfa().try_lock().expect("failed to lock pfa");
+					let mut pfa = state.pfa().lock();
 
 					// NOTE(qix-): This will almost definitely be improved in the future.
 					// NOTE(qix-): At the very least, hugepages will change this.

oro-arch-x86_64/src/interrupt.rs

@@ -3,6 +3,7 @@
 use core::arch::{asm, naked_asm};
 
 use oro_mem::mapper::AddressSegment;
+use oro_sync::Lock;
 
 use crate::{
 	isr_store_user_task_and_jmp,

oro-arch-x86_64/src/lapic.rs

@@ -13,6 +13,11 @@ pub struct Lapic {
 	base: *mut u8,
 }
 
+// SAFETY: The pointer is valid across all cores and is thus sendable.
+// SAFETY: We can guarantee that the register blocks are mapped into all
+// SAFETY: cores and reside at the same location across each.
+unsafe impl Send for Lapic {}
+
 impl Lapic {
 	/// Creates a new LAPIC controller.
 	///

oro-arch-x86_64/src/lib.rs

@@ -199,6 +199,13 @@ pub(crate) struct CoreState {
 	pub kernel_irq_stack: UnsafeCell<u64>,
 }
 
+// XXX(qix-): This is temporary. The core state is not currently used
+// XXX(qix-): across core boundaries, so we can manually mark it as `Sync`.
+// XXX(qix-): I want to fix up how the kernel guards this value so as to drop
+// XXX(qix-): the `Sync` requirement altogether, but for now this is sufficient,
+// XXX(qix-): if not a little fragile.
+unsafe impl Sync for CoreState {}
+
 /// x86_64-specific thread state.
 pub(crate) struct ThreadState {
 	/// The thread's interrupt stack pointer.

oro-debug-pl011/Cargo.toml

@@ -12,8 +12,9 @@ repository = "https://github.com/oro-os/kernel"
 license = "MPL-2.0"
 
 [dependencies]
+oro-sync.workspace = true
+
 volatile-register.workspace = true
-spin.workspace = true
 
 [lints]
 workspace = true

oro-debug-pl011/src/lib.rs

@@ -10,12 +10,12 @@ mod driver;
 
 use core::fmt::{self, Write};
 
-use spin::mutex::fair::FairMutex;
+use oro_sync::{Lock, TicketMutex};
 
 /// The shared serial port for the system.
 // NOTE(qix-): This is a temporary solution until pre-boot module loading
 // NOTE(qix-): is implemented.
-static SERIAL: FairMutex<Option<driver::PL011>> = FairMutex::new(None);
+static SERIAL: TicketMutex<Option<driver::PL011>> = TicketMutex::new(None);
 
 /// Initializes the PL011.
 pub fn init(offset: usize) {

oro-debug-uart16550/Cargo.toml

@@ -12,8 +12,9 @@ repository = "https://github.com/oro-os/kernel"
 license = "MPL-2.0"
 
 [dependencies]
+oro-sync.workspace = true
+
 uart_16550.workspace = true
-spin.workspace = true
 
 [lints]
 workspace = true

oro-debug-uart16550/src/lib.rs

@@ -4,11 +4,11 @@
 
 use core::fmt::{self, Write};
 
-use spin::mutex::fair::FairMutex;
+use oro_sync::{Lock, TicketMutex};
 use uart_16550::SerialPort;
 
 /// The shared serial port for the system.
-static SERIAL: FairMutex<SerialPort> = FairMutex::new(unsafe { SerialPort::new(0x3F8) });
+static SERIAL: TicketMutex<SerialPort> = TicketMutex::new(unsafe { SerialPort::new(0x3F8) });
 
 /// Initializes the UART.
 pub fn init() {

oro-kernel/Cargo.toml

@@ -16,8 +16,7 @@ oro-mem.workspace = true
 oro-macro.workspace = true
 oro-id.workspace = true
 oro-debug.workspace = true
-
-spin.workspace = true
+oro-sync.workspace = true
 
 [lints]
 workspace = true

oro-kernel/src/lib.rs

@@ -29,7 +29,7 @@ use oro_mem::{
 	mapper::{AddressSegment, AddressSpace, MapError, UnmapError},
 	pfa::alloc::Alloc,
 };
-use spin::mutex::fair::FairMutex;
+use oro_sync::{Lock, TicketMutex};
 
 use self::{
 	registry::{Handle, List, ListRegistry, Registry},
@@ -54,7 +54,7 @@ pub struct Kernel<A: Arch> {
 	/// The kernel scheduler.
 	///
 	/// Guaranteed valid after a successful call to `initialize_for_core`.
-	scheduler:  MaybeUninit<FairMutex<Scheduler<A>>>,
+	scheduler:  MaybeUninit<TicketMutex<Scheduler<A>>>,
 	/// Cached mapper handle for the kernel.
 	mapper:     SupervisorHandle<A>,
 }
@@ -109,7 +109,7 @@ impl<A: Arch> Kernel<A> {
 
 		(*kernel_ptr)
 			.scheduler
-			.write(FairMutex::new(Scheduler::new(&*kernel_ptr)));
+			.write(TicketMutex::new(Scheduler::new(&*kernel_ptr)));
 
 		Ok(&*kernel_ptr)
 	}
@@ -163,7 +163,7 @@ impl<A: Arch> Kernel<A> {
 	/// interrupts are disabled; the spinlock is _not_ a critical
 	/// spinlock and thus does not disable interrupts.
 	#[must_use]
-	pub unsafe fn scheduler(&self) -> &FairMutex<Scheduler<A>> {
+	pub unsafe fn scheduler(&self) -> &TicketMutex<Scheduler<A>> {
 		self.scheduler.assume_init_ref()
 	}
 }
@@ -173,7 +173,7 @@ impl<A: Arch> Kernel<A> {
 pub struct KernelState<A: Arch> {
 	/// The shared, spinlocked page frame allocator (PFA) for the
 	/// entire system.
-	pfa: FairMutex<A::Pfa>,
+	pfa: TicketMutex<A::Pfa>,
 
 	/// The base userspace address space mapper.
 	///
@@ -250,7 +250,7 @@ impl<A: Arch> KernelState<A> {
 	#[allow(clippy::missing_panics_doc)]
 	pub unsafe fn init(
 		this: &'static mut MaybeUninit<Self>,
-		pfa: FairMutex<A::Pfa>,
+		pfa: TicketMutex<A::Pfa>,
 	) -> Result<(), MapError> {
 		#[expect(clippy::missing_docs_in_private_items)]
 		macro_rules! init_registries {
@@ -348,7 +348,7 @@ impl<A: Arch> KernelState<A> {
 	}
 
 	/// Returns the underlying PFA belonging to the kernel state.
-	pub fn pfa(&'static self) -> &'static FairMutex<A::Pfa> {
+	pub fn pfa(&'static self) -> &'static TicketMutex<A::Pfa> {
 		&self.pfa
 	}
 
@@ -614,14 +614,14 @@ impl<A: Arch> KernelState<A> {
 pub trait Arch: 'static {
 	/// The type of page frame allocator (PFA) the architecture
 	/// uses.
-	type Pfa: Alloc;
+	type Pfa: Alloc + Send;
 	/// The address space layout the architecture uses.
 	type AddrSpace: AddressSpace;
 	/// Architecture-specific thread state to be stored alongside
 	/// each thread.
-	type ThreadState: Sized = ();
+	type ThreadState: Sized + Send = ();
 	/// The core-local state type.
-	type CoreState: Sized + 'static = ();
+	type CoreState: Sized + Send + Sync + 'static = ();
 
 	/// Allows the architecture to further initialize an instance
 	/// thread's mappings when threads are created.