rust/kernel: Move PointerWrapper trait to types.rs

Since usage of PointerWrapper is not limited only to file
operations, move it out from file_operations.rs to a more
suitable place, types.rs.

Fixes #144

Signed-off-by: Sumera Priyadarsini <[email protected]>

Author: Sylfrena

rust/kernel/file_operations.rs

@@ -5,15 +5,13 @@
 //! C header: [`include/linux/fs.h`](../../../../include/linux/fs.h)
 
 use core::convert::{TryFrom, TryInto};
-use core::{marker, mem, ops::Deref, pin::Pin, ptr};
-
-use alloc::boxed::Box;
-use alloc::sync::Arc;
+use core::{marker, mem, ptr};
 
 use crate::bindings;
 use crate::c_types;
 use crate::error::{Error, KernelResult};
-use crate::sync::{CondVar, Ref, RefCounted};
+use crate::sync::CondVar;
+use crate::types::PointerWrapper;
 use crate::user_ptr::{UserSlicePtr, UserSlicePtrReader, UserSlicePtrWriter};
 
 /// Wraps the kernel's `struct file`.
@@ -605,64 +603,3 @@ pub trait FileOperations: Send + Sync + Sized {
         Ok(bindings::POLLIN | bindings::POLLOUT | bindings::POLLRDNORM | bindings::POLLWRNORM)
     }
 }
-
-/// Used to convert an object into a raw pointer that represents it.
-///
-/// It can eventually be converted back into the object. This is used to store objects as pointers
-/// in kernel data structures, for example, an implementation of [`FileOperations`] in `struct
-/// file::private_data`.
-pub trait PointerWrapper<T> {
-    /// Returns the raw pointer.
-    fn into_pointer(self) -> *const T;
-
-    /// Returns the instance back from the raw pointer.
-    ///
-    /// # Safety
-    ///
-    /// The passed pointer must come from a previous call to [`PointerWrapper::into_pointer()`].
-    unsafe fn from_pointer(ptr: *const T) -> Self;
-}
-
-impl<T> PointerWrapper<T> for Box<T> {
-    fn into_pointer(self) -> *const T {
-        Box::into_raw(self)
-    }
-
-    unsafe fn from_pointer(ptr: *const T) -> Self {
-        Box::from_raw(ptr as _)
-    }
-}
-
-impl<T: RefCounted> PointerWrapper<T> for Ref<T> {
-    fn into_pointer(self) -> *const T {
-        Ref::into_raw(self)
-    }
-
-    unsafe fn from_pointer(ptr: *const T) -> Self {
-        Ref::from_raw(ptr as _)
-    }
-}
-
-impl<T> PointerWrapper<T> for Arc<T> {
-    fn into_pointer(self) -> *const T {
-        Arc::into_raw(self)
-    }
-
-    unsafe fn from_pointer(ptr: *const T) -> Self {
-        Arc::from_raw(ptr)
-    }
-}
-
-impl<T, W: PointerWrapper<T> + Deref> PointerWrapper<T> for Pin<W> {
-    fn into_pointer(self) -> *const T {
-        // SAFETY: We continue to treat the pointer as pinned by returning just a pointer to it to
-        // the caller.
-        let inner = unsafe { Pin::into_inner_unchecked(self) };
-        inner.into_pointer()
-    }
-
-    unsafe fn from_pointer(p: *const T) -> Self {
-        // SAFETY: The object was originally pinned.
-        Pin::new_unchecked(W::from_pointer(p))
-    }
-}

rust/kernel/types.rs

@@ -4,9 +4,12 @@
 //!
 //! C header: [`include/linux/types.h`](../../../../include/linux/types.h)
 
-use core::ops::Deref;
+use core::{ops::Deref, pin::Pin};
+
+use alloc::{boxed::Box, sync::Arc};
 
 use crate::bindings;
+use crate::sync::{Ref, RefCounted};
 
 /// Permissions.
 ///
@@ -71,3 +74,64 @@ macro_rules! cstr {
         unsafe { $crate::CStr::new_unchecked(s) }
     }};
 }
+
+/// Used to convert an object into a raw pointer that represents it.
+///
+/// It can eventually be converted back into the object. This is used to store objects as pointers
+/// in kernel data structures, for example, an implementation of [`FileOperations`] in `struct
+/// file::private_data`.
+pub trait PointerWrapper<T> {
+    /// Returns the raw pointer.
+    fn into_pointer(self) -> *const T;
+
+    /// Returns the instance back from the raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// The passed pointer must come from a previous call to [`PointerWrapper::into_pointer()`].
+    unsafe fn from_pointer(ptr: *const T) -> Self;
+}
+
+impl<T> PointerWrapper<T> for Box<T> {
+    fn into_pointer(self) -> *const T {
+        Box::into_raw(self)
+    }
+
+    unsafe fn from_pointer(ptr: *const T) -> Self {
+        Box::from_raw(ptr as _)
+    }
+}
+
+impl<T: RefCounted> PointerWrapper<T> for Ref<T> {
+    fn into_pointer(self) -> *const T {
+        Ref::into_raw(self)
+    }
+
+    unsafe fn from_pointer(ptr: *const T) -> Self {
+        Ref::from_raw(ptr as _)
+    }
+}
+
+impl<T> PointerWrapper<T> for Arc<T> {
+    fn into_pointer(self) -> *const T {
+        Arc::into_raw(self)
+    }
+
+    unsafe fn from_pointer(ptr: *const T) -> Self {
+        Arc::from_raw(ptr)
+    }
+}
+
+impl<T, W: PointerWrapper<T> + Deref> PointerWrapper<T> for Pin<W> {
+    fn into_pointer(self) -> *const T {
+        // SAFETY: We continue to treat the pointer as pinned by returning just a pointer to it to
+        // the caller.
+        let inner = unsafe { Pin::into_inner_unchecked(self) };
+        inner.into_pointer()
+    }
+
+    unsafe fn from_pointer(p: *const T) -> Self {
+        // SAFETY: The object was originally pinned.
+        Pin::new_unchecked(W::from_pointer(p))
+    }
+}