Merge branch 'rust' into macros

Author: wedsonaf

rust/helpers.c

@@ -627,6 +627,12 @@ void rust_helper___INIT_WORK_WITH_KEY(struct work_struct *work,
 }
 EXPORT_SYMBOL_GPL(rust_helper___INIT_WORK_WITH_KEY);
 
+struct dentry *rust_helper_dget(struct dentry *dentry)
+{
+	return dget(dentry);
+}
+EXPORT_SYMBOL_GPL(rust_helper_dget);
+
 /*
  * We use `bindgen`'s `--size_t-is-usize` option to bind the C `size_t` type
  * as the Rust `usize` type, so we can use it in contexts where Rust

rust/kernel/amba.rs

@@ -95,7 +95,7 @@ impl<T: Driver> driver::DriverOps for Adapter<T> {
         }
         // SAFETY: By the safety requirements of this function, `reg` is valid and fully
         // initialised.
-        to_result(|| unsafe { bindings::amba_driver_register(reg) })
+        to_result(unsafe { bindings::amba_driver_register(reg) })
     }
 
     unsafe fn unregister(reg: *mut bindings::amba_driver) {

rust/kernel/clk.rs

@@ -35,7 +35,7 @@ impl Clk {
     /// This function should not be called in atomic context.
     pub fn prepare_enable(self) -> Result<EnabledClk> {
         // SAFETY: The pointer is valid by the type invariant.
-        to_result(|| unsafe { bindings::clk_prepare_enable(self.0) })?;
+        to_result(unsafe { bindings::clk_prepare_enable(self.0) })?;
         Ok(EnabledClk(self))
     }
 }

rust/kernel/error.rs

@@ -551,10 +551,9 @@ pub(crate) fn from_kernel_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
     Ok(ptr)
 }
 
-/// Calls a kernel function that returns an integer error code on failure and converts the result
-/// to a [`Result`].
-pub fn to_result(func: impl FnOnce() -> core::ffi::c_int) -> Result {
-    let err = func();
+/// Converts an integer as returned by a C kernel function to an error if it's negative, and
+/// `Ok(())` otherwise.
+pub fn to_result(err: core::ffi::c_int) -> Result {
     if err < 0 {
         Err(Error::from_kernel_errno(err))
     } else {

rust/kernel/fs.rs

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! File systems.
+//!
+//! C headers: [`include/linux/fs.h`](../../../../include/linux/fs.h)
+
+use crate::{bindings, AlwaysRefCounted};
+use core::{cell::UnsafeCell, ptr};
+
+/// Wraps the kernel's `struct inode`.
+///
+/// # Invariants
+///
+/// Instances of this type are always ref-counted, that is, a call to `ihold` ensures that the
+/// allocation remains valid at least until the matching call to `iput`.
+#[repr(transparent)]
+pub struct INode(pub(crate) UnsafeCell<bindings::inode>);
+
+// SAFETY: The type invariants guarantee that `INode` is always ref-counted.
+unsafe impl AlwaysRefCounted for INode {
+    fn inc_ref(&self) {
+        // SAFETY: The existence of a shared reference means that the refcount is nonzero.
+        unsafe { bindings::ihold(self.0.get()) };
+    }
+
+    unsafe fn dec_ref(obj: ptr::NonNull<Self>) {
+        // SAFETY: The safety requirements guarantee that the refcount is nonzero.
+        unsafe { bindings::iput(obj.cast().as_ptr()) }
+    }
+}
+
+/// Wraps the kernel's `struct dentry`.
+///
+/// # Invariants
+///
+/// Instances of this type are always ref-counted, that is, a call to `dget` ensures that the
+/// allocation remains valid at least until the matching call to `dput`.
+#[repr(transparent)]
+pub struct DEntry(pub(crate) UnsafeCell<bindings::dentry>);
+
+// SAFETY: The type invariants guarantee that `DEntry` is always ref-counted.
+unsafe impl AlwaysRefCounted for DEntry {
+    fn inc_ref(&self) {
+        // SAFETY: The existence of a shared reference means that the refcount is nonzero.
+        unsafe { bindings::dget(self.0.get()) };
+    }
+
+    unsafe fn dec_ref(obj: ptr::NonNull<Self>) {
+        // SAFETY: The safety requirements guarantee that the refcount is nonzero.
+        unsafe { bindings::dput(obj.cast().as_ptr()) }
+    }
+}

rust/kernel/hwrng.rs

@@ -105,7 +105,7 @@ impl<T: Operations> Registration<T> {
         );
 
         // SAFETY: `bindings::hwrng` is initialized above which guarantees safety.
-        to_result(|| unsafe { bindings::hwrng_register(this.hwrng.get()) })?;
+        to_result(unsafe { bindings::hwrng_register(this.hwrng.get()) })?;
 
         this.registered = true;
         this.name = Some(name);