Create a Mutex<T> type backed by the kernel mutex type

Signed-off-by: Finn Behrens <[email protected]>

Author: kloenk

rust/kernel/src/lib.rs

@@ -3,7 +3,7 @@
 //! The `kernel` crate
 
 #![no_std]
-#![feature(allocator_api, alloc_error_handler)]
+#![feature(allocator_api, alloc_error_handler, const_fn_union)]
 
 // Ensure conditional compilation based on the kernel configuration works;
 // otherwise we may silently break things like initcall handling.
@@ -24,6 +24,8 @@ pub mod prelude;
 pub mod printk;
 pub mod random;
 
+pub mod sync;
+
 #[cfg(CONFIG_SYSCTL)]
 pub mod sysctl;
 

rust/kernel/src/sync.rs

@@ -0,0 +1,140 @@
+use core::cell::UnsafeCell;
+use core::ops::{Deref, DerefMut};
+
+use crate::bindings;
+
+#[cfg(CONFIG_DEBUG_SPINLOCK)]
+compile_error!("CONFIG_DEBUG_SPINLOCK not yet implemented");
+
+#[cfg(CONFIG_DEBUG_MUTEX)]
+compile_error!("CONFIG_DEBUG_MUTEX not yet implemented");
+
+fn new_spinlock(_name: &'static str) -> bindings::spinlock {
+    #[repr(C)]
+    union USpinLock {
+        none: (),
+        some: bindings::spinlock,
+    };
+
+    let lock = unsafe { USpinLock { none: {} }.some }; // FIXME: quick hack. revert and implement CONFIG_DEBUG_SPINLOCK
+
+    lock
+}
+
+/*pub struct SpinLock<T> {
+    lock: bindings::spinlock,
+    data: T,
+}
+
+impl<T> SpinLock<T> {
+    pub fn new(data: T, name: &'static str) -> Self {
+        let lock = new_spinlock(name);
+
+        Self {
+            data,
+            lock,
+        }
+    }
+
+    pub fn lock<'a>(&'a self) -> SpinLockGuard<'a, T> {
+        todo!("implement spinlockguard")
+    }
+}
+
+
+pub struct SpinLockGuard<'a, T: 'a> {
+    lock: &'a SpinLock<T>
+}*/
+
+pub struct Mutex<T> {
+    lock: *mut bindings::mutex,
+    data: UnsafeCell<T>,
+}
+
+impl<T> Mutex<T> {
+    /// Create a new Mutex
+    pub fn new(data: T, name: &'static str) -> Self {
+        unsafe {
+            let ret = Self::new_uninit(data, name);
+            ret.init(name);
+            ret
+        }
+    }
+
+    /// Create a new Mutex without spinlock and queue.
+    /// This is used for const declarations
+    pub const unsafe fn new_uninit(data: T, _name: &'static str) -> Self {
+        #[repr(C)]
+        union UMutex {
+            none: (),
+            some: bindings::mutex,
+        };
+
+        let lock = UMutex { none: () }.some;
+        let lock: *const bindings::mutex = &lock;
+        // TODO: debug foo
+        Self {
+            data: UnsafeCell::new(data),
+            lock: lock as *mut bindings::mutex,
+        }
+    }
+
+    /// Init a Mutex from a new_uninit
+    pub unsafe fn init(&self, name: &'static str) {
+        (*self.lock).wait_list = bindings::list_head {
+            prev: &mut (*self.lock).wait_list,
+            next: &mut (*self.lock).wait_list,
+        };
+
+        (*self.lock).wait_lock = new_spinlock(name);
+    }
+
+    /// acquire a lock on the mutex
+    pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
+        unsafe {
+            bindings::mutex_lock(self.lock);
+        }
+        MutexGuard { inner: &self }
+    }
+
+    /// try to acquire the lock, returns none on failure
+    pub fn try_lock<'a>(&'a self) -> Option<MutexGuard<'a, T>> {
+        let ret = unsafe { bindings::mutex_trylock(self.lock) };
+        if ret == 1 {
+            Some(MutexGuard { inner: &self })
+        } else {
+            None
+        }
+    }
+
+    fn unlock(&self) {
+        unsafe {
+            bindings::mutex_unlock(self.lock);
+        }
+    }
+    //TODO try_lock()
+}
+
+pub struct MutexGuard<'a, T> {
+    inner: &'a Mutex<T>,
+}
+
+impl<'a, T> Deref for MutexGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.inner.data.get() }
+    }
+}
+
+impl<'a, T> DerefMut for MutexGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *self.inner.data.get() }
+    }
+}
+
+impl<'a, T> Drop for MutexGuard<'a, T> {
+    fn drop(&mut self) {
+        self.inner.unlock();
+    }
+}