compiling

Author: adamrk

rust/kernel/bindings_helper.h

@@ -6,7 +6,6 @@
 #include <linux/errname.h>
 #include <linux/fs.h>
 #include <linux/module.h>
-#include <linux/proc_fs.h>
 #include <linux/random.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>

rust/kernel/debugfs.rs

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! TODOABK: finish doc
+
+use core::{
+    marker::{PhantomData, Sync},
+    ptr,
+};
+
+use crate::{bindings, c_types, error, str::CStr, types::PointerWrapper, Result};
+
+/// TODOABK: finish doc
+pub struct DebugFsDirEntry<T: PointerWrapper> {
+    dentry: *mut bindings::dentry,
+    data: *mut c_types::c_void,
+    _wrapper: PhantomData<T>,
+}
+
+// TODOABK: safety
+unsafe impl<T: PointerWrapper> Sync for DebugFsDirEntry<T> {}
+
+impl<T: PointerWrapper> DebugFsDirEntry<T> {
+    pub(crate) unsafe fn create_file(
+        name: &CStr,
+        data: T,
+        fops: &'static bindings::file_operations,
+    ) -> Result<Self> {
+        let name = name.as_char_ptr();
+        let data = data.into_pointer() as *mut _;
+        let dentry_ptr = error::from_kernel_err_ptr(unsafe {
+            bindings::debugfs_create_file(name, 0, ptr::null_mut(), data, fops)
+        });
+        match dentry_ptr {
+            Err(err) => {
+                drop(unsafe { T::from_pointer(data) });
+                Err(err)
+            }
+            Ok(dentry) => Ok(DebugFsDirEntry {
+                dentry,
+                data,
+                _wrapper: PhantomData,
+            }),
+        }
+    }
+}
+
+impl<T: PointerWrapper> Drop for DebugFsDirEntry<T> {
+    fn drop(&mut self) {
+        // TODOABK: safety
+        unsafe {
+            bindings::debugfs_remove(self.dentry);
+        }
+        // SAFETY: `self.data` was created by a call to `T::into_pointer`.
+        unsafe { drop(T::from_pointer(self.data)) }
+    }
+}

rust/kernel/lib.rs

@@ -48,6 +48,8 @@ pub mod chrdev;
 #[cfg(CONFIG_COMMON_CLK)]
 pub mod clk;
 pub mod cred;
+#[cfg(CONFIG_DEBUG_FS)]
+pub mod debugfs;
 pub mod device;
 pub mod driver;
 mod error;
@@ -75,9 +77,6 @@ mod build_assert;
 pub mod prelude;
 pub mod print;
 
-#[cfg(CONFIG_PROC_FS)]
-pub mod proc_fs;
-
 pub mod random;
 pub mod seq_file;
 mod static_assert;

rust/kernel/seq_file.rs

@@ -13,14 +13,18 @@
 #![cfg(CONFIG_PROC_FS)]
 
 use core::{
-    iter::{Iterator, Peekable},
+    fmt::{self, Display},
     marker::PhantomData,
-    mem,
-    ops::{Deref, DerefMut},
-    ptr,
+    mem, ptr,
 };
 
-use crate::{bindings, c_str, c_types, str::CStr, types::PointerWrapper, Result};
+use crate::{
+    bindings, c_str, c_types,
+    debugfs::DebugFsDirEntry,
+    str::{CStr, CString},
+    types::PointerWrapper,
+    Result,
+};
 
 /// Rust equivalent of the [`seq_operations`] interface on the C side.
 ///
@@ -54,22 +58,30 @@ use crate::{bindings, c_str, c_types, str::CStr, types::PointerWrapper, Result};
 /// [`seq_operations`]: ../../../include/linux/seq_file.h
 pub trait SeqOperations {
     /// Type produced on each iteration.
-    type Item;
-
-    /// Type created when the seq file is opened.
-    type Iterator: Iterator<Item = Self::Item>;
+    type Item: Display;
 
     /// Wrapper used to store a pointer to `Self` on the C side.
-    type DataWrapper: PointerWrapper + Deref<Target = Self>;
+    type DataWrapper: PointerWrapper;
 
     /// Wrapper used to store a pointer to the iterator on the C side.
-    type IteratorWrapper: PointerWrapper + DerefMut<Target = Peekable<Self::Iterator>>;
+    type IteratorWrapper: PointerWrapper;
+
+    /// TODOABK
+    type OpenData: PointerWrapper + Sync;
 
     /// Called once each time the `seq_file` is opened.
-    fn start(&self) -> Result<Self::IteratorWrapper>;
+    fn start(data: &Self::DataWrapper) -> Option<Self::IteratorWrapper>;
 
-    /// How the item will be displayed to the reader.
-    fn display(item: &Self::Item) -> &str;
+    /// TODOABK: docs
+    fn next(iterator: &mut Self::IteratorWrapper) -> bool;
+
+    /// TODOABK: docs
+    fn current(iterator: &Self::IteratorWrapper) -> Option<Self::Item>;
+
+    /// TODOABK: docs
+    fn open<'a>(
+        open_data: <Self::OpenData as PointerWrapper>::Borrowed<'a>,
+    ) -> Result<Self::DataWrapper>;
 }
 
 extern "C" fn stop_callback<T: SeqOperations>(
@@ -105,21 +117,18 @@ extern "C" fn next_callback<T: SeqOperations>(
         *pos += 1;
     }
 
-    if iterator.next().is_none() {
-        return ptr::null_mut();
-    }
-
-    match iterator.peek() {
-        Some(_next) => T::IteratorWrapper::into_pointer(iterator) as *mut _,
-        None => ptr::null_mut(),
+    if !T::next(&mut iterator) {
+        ptr::null_mut()
+    } else {
+        T::IteratorWrapper::into_pointer(iterator) as *mut _
     }
 }
 
 extern "C" fn show_callback<T: SeqOperations>(
     m: *mut bindings::seq_file,
     v: *mut c_types::c_void,
 ) -> c_types::c_int {
-    const FORMAT: &CStr = c_str!("%.*s");
+    const FORMAT: &CStr = c_str!("%pA");
     if v.is_null() {
         return 0;
     }
@@ -128,18 +137,16 @@ extern "C" fn show_callback<T: SeqOperations>(
     // or pointer generated by `T::IteratorWrapper::into_pointer`. We
     // checked for null pointers above. The iterator is forgotten below
     // so the pointer on the C side stays valid.
-    let mut iterator = unsafe { T::IteratorWrapper::from_pointer(v) };
-    if let Some(item) = iterator.peek() {
-        let s = T::display(item);
+    let iterator = unsafe { T::IteratorWrapper::from_pointer(v) };
+    if let Some(item) = T::current(&iterator) {
         // SAFETY: Calling a C function. `FORMAT` is null terminated because
         // it comes from a `CStr`. `s` does not need to be null terminated
         // because we are only printing the first `s.len()` bytes.
         unsafe {
             bindings::seq_printf(
                 m,
-                FORMAT.as_char_ptr(),
-                s.len(),
-                s.as_ptr() as *const u8 as *const c_types::c_char,
+                (FORMAT as *const _) as *const _,
+                (&format_args!("{}", item) as *const _) as *const _,
             );
         }
     }
@@ -158,55 +165,64 @@ extern "C" fn start_callback<T: SeqOperations>(
     // `T::DataWrapper::into_pointer`. We don't move the data in the wrapper
     // so the pointer will remain valid for later calls.
     let data_wrapper = unsafe { T::DataWrapper::from_pointer((*m).private) };
-    let iterator = data_wrapper.start().ok();
+    let iterator = T::start(&data_wrapper);
     // Data is still used in the `proc_dir_entry`.
     mem::forget(data_wrapper);
     // SAFETY: The caller guarantees that `pos` points to a valid `loff_t`.
     let pos = unsafe { *pos };
     match iterator {
         Some(mut wrapper) => {
             for _ in 0..pos {
-                if wrapper.next().is_none() {
+                if !T::next(&mut wrapper) {
                     return ptr::null_mut();
                 }
             }
-            match wrapper.peek() {
-                Some(_next) => T::IteratorWrapper::into_pointer(wrapper) as *mut _,
-                None => ptr::null_mut(),
-            }
+            T::IteratorWrapper::into_pointer(wrapper) as *mut _
         }
         None => ptr::null_mut(),
     }
 }
 
 pub(crate) struct SeqFileOperationsVTable<T>(PhantomData<T>);
 
-impl<T: SeqOperations> SeqFileOperationsVTable<T> {
+impl<'a, T, D: 'a> SeqFileOperationsVTable<T>
+where
+    T: SeqOperations<DataWrapper = D>,
+    D: PointerWrapper,
+{
     const SEQ_VTABLE: bindings::seq_operations = bindings::seq_operations {
         start: Some(start_callback::<T>),
         stop: Some(stop_callback::<T>),
         next: Some(next_callback::<T>),
         show: Some(show_callback::<T>),
     };
 
-    // TODOABK: safety
-    pub(crate) const unsafe fn seq_build() -> &'static bindings::seq_operations {
-        &Self::SEQ_VTABLE
-    }
-
     extern "C" fn open_callback(
         inode: *mut bindings::inode,
         file: *mut bindings::file,
     ) -> c_types::c_int {
         // TODOABK: docs
-        unsafe {
-            bindings::seq_open_private(
+        let result = unsafe {
+            bindings::seq_open(
                 file,
                 &Self::SEQ_VTABLE as *const _ as *mut bindings::seq_operations,
-                // TODOABK: how to convert safely?
-                mem::size_of::<T::DataWrapper>() as i32,
             )
+        };
+        if result != 0 {
+            // Close file?
+            return result;
         }
+
+        let open_data = unsafe { T::OpenData::borrow((*inode).i_private) };
+
+        let data_wrapper = match T::open(open_data) {
+            Ok(data) => data,
+            Err(err) => return err.to_kernel_errno(),
+        };
+
+        unsafe { *((*file).private_data as *mut bindings::seq_file) }.private =
+            data_wrapper.into_pointer() as *mut _;
+        result
     }
 
     const VTABLE: bindings::file_operations = bindings::file_operations {
@@ -244,9 +260,27 @@ impl<T: SeqOperations> SeqFileOperationsVTable<T> {
         write: None,
         write_iter: None,
     };
+}
 
-    // TODOABK: safety
-    pub(crate) const unsafe fn build() -> &'static bindings::file_operations {
-        &Self::VTABLE
-    }
+/// TODOABK: docs
+pub struct SeqFileDebugFsDirEntry<T: SeqOperations> {
+    _debugfs_entry: DebugFsDirEntry<T::DataWrapper>,
+}
+
+/// TODOABK: finish doc
+pub fn debugfs_create_file<'a, T, D: 'a>(
+    name: fmt::Arguments<'_>,
+    data: D,
+) -> Result<SeqFileDebugFsDirEntry<T>>
+where
+    T: SeqOperations<DataWrapper = D>,
+    D: PointerWrapper + Clone,
+{
+    let name = CString::try_from_fmt(name)?;
+    let debugfs_entry = unsafe {
+        DebugFsDirEntry::create_file(&name, data, &SeqFileOperationsVTable::<T>::VTABLE)
+    }?;
+    Ok(SeqFileDebugFsDirEntry {
+        _debugfs_entry: debugfs_entry,
+    })
 }