From 5dc85e7f47c336cefccdbc41cea7ebe3716111ae Mon Sep 17 00:00:00 2001
From: Christian Cunningham <cc@localhost>
Date: Tue, 23 Aug 2022 21:01:49 -0700
Subject: Migrate to PIC-OS

---
 Cargo.toml  |  1 +
 src/sync.rs | 63 +------------------------------------------------------------
 2 files changed, 2 insertions(+), 62 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7f7f81c..468cfac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,3 +18,4 @@ name = "kernel"
 path = "src/kernel.rs"
 
 [dependencies]
+os_pic = {git="https://git.christiancunningham.xyz/os_pic.git"}
diff --git a/src/sync.rs b/src/sync.rs
index cd626fa..373e8f8 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -1,62 +1 @@
-//! # Synchronization module
-//!
-//! Provides synchronization objects for thread-safe memory sharing.
-use core::cell::UnsafeCell;
-
-/// # Synchronization interfaces
-///
-/// Provides Synchronization traits.
-pub mod interface {
-	/// # Mutex Trait
-	///
-	/// Basic Locking primitive to allow single-process access to data
-	pub trait Mutex {
-		/// # The data
-		///
-		/// Each mutex protects some internal data from modification across
-		/// processes when it is in use. This is important if the process
-		/// is preempted while the function is using it.
-		type Data;
-		/// # Locking mechanism
-		///
-		/// Locks the mutex to access the data in a closure.
-		/// The data can be read and modified in this closure without worry
-		/// of poisoning the data across processes.
-		fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
-	}
-}
-
-/// # Basic Lock Structure
-pub struct NullLock<T> where T: ?Sized {
-	/// The internal data to safely share
-	data: UnsafeCell<T>,
-}
-
-/// # Allow thread sharing
-unsafe impl<T> Send for NullLock<T> where T: ?Sized + Send {}
-/// # Allow thread sharing
-unsafe impl<T> Sync for NullLock<T> where T: ?Sized + Send {}
-
-impl<T> NullLock<T> {
-	/// # Create a new instance of the lock
-	pub const fn new(data: T) -> Self {
-		Self {
-			data: UnsafeCell::new(data),
-		}
-	}
-}
-
-impl<T> interface::Mutex for NullLock<T> {
-	/// # Underlying data of the lock
-	type Data = T;
-
-	/// # Locking mechanism
-	///
-	/// Locks the Mutex, and passes a mutable reference
-	/// to the encapsulated data to a closure.
-	fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut T) -> R) -> R {
-		let data = unsafe { &mut *self.data.get() };
-
-		f(data)
-	}
-}
+pub use os_pic::sync::*;
-- 
cgit v1.2.1