ldd ch04: fix build errors of rust/kernel/proc.rs

Author: gurugio

rust/kernel/lib.rs

@@ -50,6 +50,7 @@ pub mod mm;
 pub mod pages;
 pub mod prelude;
 pub mod print;
+pub mod proc;
 mod static_assert;
 #[doc(hidden)]
 pub mod std_vendor;
@@ -62,7 +63,6 @@ pub mod user_ptr;
 #[doc(hidden)]
 pub use bindings;
 pub use macros;
-pub use proc;
 pub use uapi;
 
 #[doc(hidden)]

rust/kernel/proc.rs

@@ -8,7 +8,7 @@
 
 use crate::{
     bindings,
-    error::{from_kernel_result, Result},
+    error::{from_err_ptr, from_result, Result},
     fmt,
     str::CString,
 };
@@ -23,19 +23,17 @@ impl<T: ProcOperations> ProcOperationsVtable<T> {
         _inode: *mut bindings::inode,
         _file: *mut bindings::file,
     ) -> core::ffi::c_int {
-        from_kernel_result! {
-            T::proc_open(_inode, _file)
-        }
+        from_result(|| T::proc_open(_inode, _file))
     }
 
     unsafe extern "C" fn proc_release(
         _inode: *mut bindings::inode,
         _file: *mut bindings::file,
     ) -> core::ffi::c_int {
-        from_kernel_result! {
+        from_result(|| {
             let _ = T::proc_release(_inode, _file);
             Ok(0)
-        }
+        })
     }
 
     unsafe extern "C" fn proc_read(
@@ -44,19 +42,15 @@ impl<T: ProcOperations> ProcOperationsVtable<T> {
         _size: usize,
         _ppos: *mut bindings::loff_t,
     ) -> isize {
-        from_kernel_result! {
-            T::proc_read(_file, _buf, _size, _ppos)
-        }
+        from_result(|| T::proc_read(_file, _buf, _size, _ppos))
     }
 
     unsafe extern "C" fn proc_lseek(
         _file: *mut bindings::file,
         _offset: bindings::loff_t,
         _whence: core::ffi::c_int,
     ) -> bindings::loff_t {
-        from_kernel_result! {
-            T::proc_lseek(_file, _offset, _whence)
-        }
+        from_result(|| T::proc_lseek(_file, _offset, _whence))
     }
 
     const VTABLE: bindings::proc_ops = bindings::proc_ops {
@@ -119,45 +113,40 @@ pub trait ProcOperations {
 
 /// TBD
 pub struct RustProcRegistration {
-    _parent: *mut bindings::proc_dir_entry,
-    _entry: *mut bindings::proc_dir_entry,
+    parent: *mut bindings::proc_dir_entry,
+    dir: *mut bindings::proc_dir_entry,
+    entry: *mut bindings::proc_dir_entry,
     _pin: PhantomPinned,
 }
 
 impl RustProcRegistration {
     /// TBD
-    pub fn new(parent: *mut bindings::proc_dir_entry) -> Self {
+    pub fn new(parent: *mut bindings::proc_dir_entry, filename: CString) -> Self {
         Self {
-            _parent: parent,
-            _entry: ptr::null_mut(),
+            parent,
+            dir: ptr::null_mut(),
+            entry: ptr::null_mut(),
             _pin: PhantomPinned,
         }
     }
 
-    pub fn mkdir(&self, name: &CString) -> Result<()> {
-        // TODO: implement!
-        let parent = bindings::proc_mkdir(
-            CString::try_from_fmt(fmt!("{}", PROC_FS_NAME))?.as_char_ptr(),
-            ptr::null_mut(),
-        );
+    pub fn mkdir(&mut self, name: &CString) -> Result<()> {
+        self.dir = unsafe { from_err_ptr(bindings::proc_mkdir(name.as_char_ptr(), self.parent)) }?;
         Ok(())
     }
 
     /// TBD
-    pub fn register<T: ProcOperations<OpenData = ()>>(&self) -> Result<()> {
-        let entry_name = CString::try_from_fmt(fmt!("{}", PROC_FS_NAME))?;
-
+    pub fn register<T: ProcOperations<OpenData = ()>>(&mut self, filename: &CString) -> Result<()> {
         let entry: *mut bindings::proc_dir_entry = unsafe {
-            bindings::proc_create(
-                entry_name.as_char_ptr(),
+            from_err_ptr(bindings::proc_create(
+                filename.as_char_ptr(),
                 0o644,
-                self._parent,
+                self.dir,
                 ProcOperationsVtable::<T>::build(),
-            )
-        };
-        // TODO: How to check entry?
-        if entry.is_null() {}
+            ))
+        }?;
 
+        self.entry = entry;
         Ok(())
     }
 }
@@ -168,10 +157,12 @@ unsafe impl Sync for RustProcRegistration {}
 impl Drop for RustProcRegistration {
     fn drop(&mut self) {
         unsafe {
-            let entry_name = CString::try_from_fmt(fmt!("{}", PROC_FS_NAME)).unwrap();
-            bindings::remove_proc_entry(entry_name.as_char_ptr(), self._parent);
-            let parent_name = CString::try_from_fmt(fmt!("{}", SUB_DIR_NAME)).unwrap();
-            bindings::remove_proc_entry(_SUB_DIR_NAME.as_char_ptr(), ptr::null_mut());
+            //let entry_name = CString::try_from_fmt(fmt!("{}", PROC_FS_NAME)).unwrap();
+            //bindings::remove_proc_entry(entry_name.as_char_ptr(), self._parent);
+            //let parent_name = CString::try_from_fmt(fmt!("{}", SUB_DIR_NAME)).unwrap();
+            //bindings::remove_proc_entry(_SUB_DIR_NAME.as_char_ptr(), ptr::null_mut());
+            bindings::proc_remove(self.entry);
+            bindings::proc_remove(self.dir)
         }
     }
 }

samples/rust/Makefile

@@ -5,6 +5,6 @@ obj-$(CONFIG_SAMPLE_RUST_PRINT)			+= rust_print.o
 obj-$(CONFIG_SAMPLE_RUST_FS)			+= rust_fs.o
 obj-$(CONFIG_SAMPLE_RUST_LDD02)			+= rust_ldd02.o
 obj-$(CONFIG_SAMPLE_RUST_LDD03)			+= rust_ldd03.o
-obj-$(CONFIG_SAMPLE_RUST_LDD04)			+= rust_proc.o
+obj-$(CONFIG_SAMPLE_RUST_LDD04)			+= rust_ldd04.o
 
 subdir-$(CONFIG_SAMPLE_RUST_HOSTPROGS)		+= hostprogs

samples/rust/rust_proc.rs renamed to samples/rust/rust_ldd04.rs

@@ -106,7 +106,7 @@ impl kernel::Module for RustProc {
         pr_info!("{} is loaded\n", name.to_str()?);
         pr_info!("proc_show={:#x}\n", proc_show as *mut ffi::c_void as usize);
 
-        let reg = RustProcRegistration::new(parent);
+        let reg = RustProcRegistration::new(core::ptr::null_mut());
         reg.mkdir(parent_name)?;
         reg.register::<Token>()?;