Fix errors

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

Author: Sylfrena

rust/kernel/file_operations.rs

@@ -530,7 +530,7 @@ pub trait FileOperations: Send + Sync + Sized {
     const TO_USE: ToUse;
 
     /// The pointer type that will be used to hold ourselves.
-    type Wrapper: PointerWrapper<Self>;
+    type Wrapper: PointerWrapper;
 
     /// Cleans up after the last reference to the file goes away.
     ///

rust/kernel/types.rs

@@ -9,6 +9,7 @@ use core::{ops::Deref, pin::Pin};
 use alloc::{boxed::Box, sync::Arc};
 
 use crate::bindings;
+use crate::c_types;
 use crate::sync::{Ref, RefCounted};
 
 /// Permissions.
@@ -82,56 +83,56 @@ macro_rules! cstr {
 /// file::private_data`.
 pub trait PointerWrapper {
     /// Returns the raw pointer.
-    fn into_pointer(self) -> *const T;
+    fn into_pointer(self) -> *const c_types::c_void;
 
     /// 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;
+    unsafe fn from_pointer(ptr: *const c_types::c_void) -> Self;
 }
 
 impl<T> PointerWrapper for Box<T> {
-    fn into_pointer(self) -> *const T {
-        Box::into_raw(self)
+    fn into_pointer(self) -> *const c_types::c_void {
+        Box::into_raw(self) as _
     }
 
-    unsafe fn from_pointer(ptr: *const T) -> Self {
+    unsafe fn from_pointer(ptr: *const c_types::c_void) -> Self {
         Box::from_raw(ptr as _)
     }
 }
 
 impl<T: RefCounted> PointerWrapper for Ref<T> {
-    fn into_pointer(self) -> *const T {
-        Ref::into_raw(self)
+    fn into_pointer(self) -> *const c_types::c_void {
+        Ref::into_raw(self) as _
     }
 
-    unsafe fn from_pointer(ptr: *const T) -> Self {
+    unsafe fn from_pointer(ptr: *const c_types::c_void) -> Self {
         Ref::from_raw(ptr as _)
     }
 }
 
 impl<T> PointerWrapper for Arc<T> {
-    fn into_pointer(self) -> *const T {
-        Arc::into_raw(self)
+    fn into_pointer(self) -> *const c_types::c_void {
+        Arc::into_raw(self) as _
     }
 
-    unsafe fn from_pointer(ptr: *const T) -> Self {
-        Arc::from_raw(ptr)
+    unsafe fn from_pointer(ptr: *const c_types::c_void) -> Self {
+        Arc::from_raw(ptr as _)
     }
 }
 
-impl<T, W: PointerWrapper + Deref> PointerWrapper for Pin<W> {
-    fn into_pointer(self) -> *const T {
+impl<T: PointerWrapper + Deref> PointerWrapper for Pin<T> {
+    fn into_pointer(self) -> *const c_types::c_void {
         // 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 {
+    unsafe fn from_pointer(p: *const c_types::c_void) -> Self {
         // SAFETY: The object was originally pinned.
-        Pin::new_unchecked(W::from_pointer(p))
+        Pin::new_unchecked(T::from_pointer(p))
     }
 }