rust: use the generated helper bindings

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

rust/helpers.c

@@ -13,7 +13,7 @@
 #include <linux/security.h>
 #include <asm/io.h>
 
-void rust_helper_BUG(void)
+__noreturn void rust_helper_BUG(void)
 {
 	BUG();
 }
@@ -91,16 +91,16 @@ void rust_helper_writeq(u64 value, volatile void __iomem *addr)
 EXPORT_SYMBOL_GPL(rust_helper_writeq);
 #endif
 
-void rust_helper_spin_lock_init(spinlock_t *lock, const char *name,
-				struct lock_class_key *key)
+void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
+				  struct lock_class_key *key)
 {
 #ifdef CONFIG_DEBUG_SPINLOCK
 	__spin_lock_init(lock, name, key);
 #else
 	spin_lock_init(lock);
 #endif
 }
-EXPORT_SYMBOL_GPL(rust_helper_spin_lock_init);
+EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);
 
 void rust_helper_spin_lock(spinlock_t *lock)
 {
@@ -162,22 +162,23 @@ size_t rust_helper_copy_to_iter(const void *addr, size_t bytes, struct iov_iter
 }
 EXPORT_SYMBOL_GPL(rust_helper_copy_to_iter);
 
-bool rust_helper_is_err(__force const void *ptr)
+bool rust_helper_IS_ERR(__force const void *ptr)
 {
 	return IS_ERR(ptr);
 }
-EXPORT_SYMBOL_GPL(rust_helper_is_err);
+EXPORT_SYMBOL_GPL(rust_helper_IS_ERR);
 
-long rust_helper_ptr_err(__force const void *ptr)
+long rust_helper_PTR_ERR(__force const void *ptr)
 {
 	return PTR_ERR(ptr);
 }
-EXPORT_SYMBOL_GPL(rust_helper_ptr_err);
+EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR);
 
 const char *rust_helper_errname(int err)
 {
 	return errname(err);
 }
+EXPORT_SYMBOL_GPL(rust_helper_errname);
 
 void rust_helper_mutex_lock(struct mutex *lock)
 {
@@ -200,11 +201,11 @@ rust_helper_platform_set_drvdata(struct platform_device *pdev,
 }
 EXPORT_SYMBOL_GPL(rust_helper_platform_set_drvdata);
 
-refcount_t rust_helper_refcount_new(void)
+refcount_t rust_helper_REFCOUNT_INIT(int n)
 {
-	return (refcount_t)REFCOUNT_INIT(1);
+	return (refcount_t)REFCOUNT_INIT(n);
 }
-EXPORT_SYMBOL_GPL(rust_helper_refcount_new);
+EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT);
 
 void rust_helper_refcount_inc(refcount_t *r)
 {

rust/kernel/error.rs

@@ -351,11 +351,8 @@ impl Error {
 
 impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        extern "C" {
-            fn rust_helper_errname(err: c_types::c_int) -> *const c_types::c_char;
-        }
         // SAFETY: FFI call.
-        let name = unsafe { rust_helper_errname(-self.0) };
+        let name = unsafe { bindings::errname(-self.0) };
 
         if name.is_null() {
             // Print out number if no name can be found.
@@ -452,7 +449,7 @@ where
 /// ) -> c_types::c_int {
 ///     from_kernel_result! {
 ///         let ptr = devm_alloc(pdev)?;
-///         rust_helper_platform_set_drvdata(pdev, ptr);
+///         bindings::platform_set_drvdata(pdev, ptr);
 ///         Ok(0)
 ///     }
 /// }
@@ -496,28 +493,20 @@ macro_rules! from_kernel_result {
 // TODO: remove `dead_code` marker once an in-kernel client is available.
 #[allow(dead_code)]
 pub(crate) fn from_kernel_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
-    extern "C" {
-        #[allow(improper_ctypes)]
-        fn rust_helper_is_err(ptr: *const c_types::c_void) -> bool;
-
-        #[allow(improper_ctypes)]
-        fn rust_helper_ptr_err(ptr: *const c_types::c_void) -> c_types::c_long;
-    }
-
     // CAST: casting a pointer to `*const c_types::c_void` is always valid.
     let const_ptr: *const c_types::c_void = ptr.cast();
     // SAFETY: the FFI function does not deref the pointer.
-    if unsafe { rust_helper_is_err(const_ptr) } {
+    if unsafe { bindings::IS_ERR(const_ptr) } {
         // SAFETY: the FFI function does not deref the pointer.
-        let err = unsafe { rust_helper_ptr_err(const_ptr) };
-        // CAST: if `rust_helper_is_err()` returns `true`,
-        // then `rust_helper_ptr_err()` is guaranteed to return a
+        let err = unsafe { bindings::PTR_ERR(const_ptr) };
+        // CAST: if `IS_ERR()` returns `true`,
+        // then `PTR_ERR()` is guaranteed to return a
         // negative value greater-or-equal to `-bindings::MAX_ERRNO`,
         // which always fits in an `i16`, as per the invariant above.
         // And an `i16` always fits in an `i32`. So casting `err` to
         // an `i32` can never overflow, and is always valid.
         //
-        // SAFETY: `rust_helper_is_err()` ensures `err` is a
+        // SAFETY: `IS_ERR()` ensures `err` is a
         // negative value greater-or-equal to `-bindings::MAX_ERRNO`
         return Err(unsafe { Error::from_kernel_errno_unchecked(err as i32) });
     }

rust/kernel/io_mem.rs

@@ -4,26 +4,9 @@
 //!
 //! C header: [`include/asm-generic/io.h`](../../../../include/asm-generic/io.h)
 
-use crate::{bindings, c_types, Error, Result};
+use crate::{bindings, Error, Result};
 use core::convert::TryInto;
 
-extern "C" {
-    fn rust_helper_ioremap(
-        offset: bindings::resource_size_t,
-        size: c_types::c_ulong,
-    ) -> *mut c_types::c_void;
-
-    fn rust_helper_readb(addr: *const c_types::c_void) -> u8;
-    fn rust_helper_readw(addr: *const c_types::c_void) -> u16;
-    fn rust_helper_readl(addr: *const c_types::c_void) -> u32;
-    fn rust_helper_readq(addr: *const c_types::c_void) -> u64;
-
-    fn rust_helper_writeb(value: u8, addr: *mut c_types::c_void);
-    fn rust_helper_writew(value: u16, addr: *mut c_types::c_void);
-    fn rust_helper_writel(value: u32, addr: *mut c_types::c_void);
-    fn rust_helper_writeq(value: u64, addr: *mut c_types::c_void);
-}
-
 /// Represents a memory resource.
 pub struct Resource {
     offset: bindings::resource_size_t,
@@ -88,7 +71,7 @@ macro_rules! define_read {
             // SAFETY: The type invariants guarantee that `ptr` is a valid pointer. The check above
             // guarantees that the code won't build if `offset` makes the read go out of bounds
             // (including the type size).
-            unsafe { concat_idents!(rust_helper_, $name)(ptr as _) }
+            unsafe { bindings::$name(ptr as _) }
         }
 
         /// Reads IO data from the given offset.
@@ -102,7 +85,7 @@ macro_rules! define_read {
             // SAFETY: The type invariants guarantee that `ptr` is a valid pointer. The check above
             // returns an error if `offset` would make the read go out of bounds (including the
             // type size).
-            Ok(unsafe { concat_idents!(rust_helper_, $name)(ptr as _) })
+            Ok(unsafe { bindings::$name(ptr as _) })
         }
     };
 }
@@ -118,7 +101,7 @@ macro_rules! define_write {
             // SAFETY: The type invariants guarantee that `ptr` is a valid pointer. The check above
             // guarantees that the code won't link if `offset` makes the write go out of bounds
             // (including the type size).
-            unsafe { concat_idents!(rust_helper_, $name)(value, ptr as _) }
+            unsafe { bindings::$name(value, ptr as _) }
         }
 
         /// Writes IO data to the given offset.
@@ -132,7 +115,7 @@ macro_rules! define_write {
             // SAFETY: The type invariants guarantee that `ptr` is a valid pointer. The check above
             // returns an error if `offset` would make the write go out of bounds (including the
             // type size).
-            unsafe { concat_idents!(rust_helper_, $name)(value, ptr as _) };
+            unsafe { bindings::$name(value, ptr as _) };
             Ok(())
         }
     };
@@ -165,9 +148,7 @@ impl<const SIZE: usize> IoMem<SIZE> {
 
         // Try to map the resource.
         // SAFETY: Just mapping the memory range.
-        // TODO: Remove `into` call below (and disabling of clippy warning) once #465 is fixed.
-        #[allow(clippy::complexity)]
-        let addr = unsafe { rust_helper_ioremap(res.offset, res.size.into()) };
+        let addr = unsafe { bindings::ioremap(res.offset, res.size as _) };
         if addr.is_null() {
             Err(Error::ENOMEM)
         } else {

rust/kernel/iov_iter.rs

@@ -5,26 +5,12 @@
 //! C header: [`include/linux/uio.h`](../../../../include/linux/uio.h)
 
 use crate::{
-    bindings, c_types,
+    bindings,
     error::Error,
     io_buffer::{IoBufferReader, IoBufferWriter},
     Result,
 };
 
-extern "C" {
-    fn rust_helper_copy_to_iter(
-        addr: *const c_types::c_void,
-        bytes: usize,
-        i: *mut bindings::iov_iter,
-    ) -> usize;
-
-    fn rust_helper_copy_from_iter(
-        addr: *mut c_types::c_void,
-        bytes: usize,
-        i: *mut bindings::iov_iter,
-    ) -> usize;
-}
-
 /// Wraps the kernel's `struct iov_iter`.
 ///
 /// # Invariants
@@ -70,7 +56,7 @@ impl IoBufferWriter for IovIter {
     }
 
     unsafe fn write_raw(&mut self, data: *const u8, len: usize) -> Result {
-        let res = unsafe { rust_helper_copy_to_iter(data as _, len, self.ptr) };
+        let res = unsafe { bindings::copy_to_iter(data as _, len, self.ptr) };
         if res != len {
             Err(Error::EFAULT)
         } else {
@@ -85,7 +71,7 @@ impl IoBufferReader for IovIter {
     }
 
     unsafe fn read_raw(&mut self, out: *mut u8, len: usize) -> Result {
-        let res = unsafe { rust_helper_copy_from_iter(out as _, len, self.ptr) };
+        let res = unsafe { bindings::copy_from_iter(out as _, len, self.ptr) };
         if res != len {
             Err(Error::EFAULT)
         } else {

rust/kernel/lib.rs

@@ -232,10 +232,11 @@ macro_rules! container_of {
 #[cfg(not(any(testlib, test)))]
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
-    extern "C" {
-        fn rust_helper_BUG() -> !;
-    }
     pr_emerg!("{}\n", info);
     // SAFETY: FFI call.
-    unsafe { rust_helper_BUG() };
+    unsafe { bindings::BUG() };
+    // Bindgen currently does not recognize `__noreturn` so `BUG` returns `()`
+    // instead of `!`.
+    // https://github.com/rust-lang/rust-bindgen/issues/2094
+    loop {}
 }

rust/kernel/pages.rs

@@ -10,20 +10,6 @@ use crate::{
 };
 use core::{marker::PhantomData, ptr};
 
-extern "C" {
-    #[allow(improper_ctypes)]
-    fn rust_helper_alloc_pages(
-        gfp_mask: bindings::gfp_t,
-        order: c_types::c_uint,
-    ) -> *mut bindings::page;
-
-    #[allow(improper_ctypes)]
-    fn rust_helper_kmap(page: *mut bindings::page) -> *mut c_types::c_void;
-
-    #[allow(improper_ctypes)]
-    fn rust_helper_kunmap(page: *mut bindings::page);
-}
-
 /// A set of physical pages.
 ///
 /// `Pages` holds a reference to a set of pages of order `ORDER`. Having the order as a generic
@@ -42,7 +28,7 @@ impl<const ORDER: u32> Pages<ORDER> {
         // TODO: Consider whether we want to allow callers to specify flags.
         // SAFETY: This only allocates pages. We check that it succeeds in the next statement.
         let pages = unsafe {
-            rust_helper_alloc_pages(
+            bindings::alloc_pages(
                 bindings::GFP_KERNEL | bindings::__GFP_ZERO | bindings::__GFP_HIGHMEM,
                 ORDER,
             )
@@ -141,7 +127,7 @@ impl<const ORDER: u32> Pages<ORDER> {
         let page = unsafe { self.pages.add(index) };
 
         // SAFETY: `page` is valid based on the checks above.
-        let ptr = unsafe { rust_helper_kmap(page) };
+        let ptr = unsafe { bindings::kmap(page) };
         if ptr.is_null() {
             return None;
         }
@@ -171,6 +157,6 @@ impl Drop for PageMapping<'_> {
     fn drop(&mut self) {
         // SAFETY: An instance of `PageMapping` is created only when `kmap` succeeded for the given
         // page, so it is safe to unmap it here.
-        unsafe { rust_helper_kunmap(self.page) };
+        unsafe { bindings::kunmap(self.page) };
     }
 }

rust/kernel/platdev.rs

@@ -29,19 +29,6 @@ pub struct Registration {
 // (it is fine for multiple threads to have a shared reference to it).
 unsafe impl Sync for Registration {}
 
-extern "C" {
-    #[allow(improper_ctypes)]
-    fn rust_helper_platform_get_drvdata(
-        pdev: *const bindings::platform_device,
-    ) -> *mut c_types::c_void;
-
-    #[allow(improper_ctypes)]
-    fn rust_helper_platform_set_drvdata(
-        pdev: *mut bindings::platform_device,
-        data: *mut c_types::c_void,
-    );
-}
-
 extern "C" fn probe_callback<P: PlatformDriver>(
     pdev: *mut bindings::platform_device,
 ) -> c_types::c_int {
@@ -52,7 +39,7 @@ extern "C" fn probe_callback<P: PlatformDriver>(
         let drv_data = drv_data.into_pointer() as *mut c_types::c_void;
         // SAFETY: `pdev` is guaranteed to be a valid, non-null pointer.
         unsafe {
-            rust_helper_platform_set_drvdata(pdev, drv_data);
+            bindings::platform_set_drvdata(pdev, drv_data);
         }
         Ok(0)
     }
@@ -65,7 +52,7 @@ extern "C" fn remove_callback<P: PlatformDriver>(
         // SAFETY: `pdev` is guaranteed to be a valid, non-null pointer.
         let device_id = unsafe { (*pdev).id };
         // SAFETY: `pdev` is guaranteed to be a valid, non-null pointer.
-        let ptr = unsafe { rust_helper_platform_get_drvdata(pdev) };
+        let ptr = unsafe { bindings::platform_get_drvdata(pdev) };
         // SAFETY:
         //   - we allocated this pointer using `P::DrvData::into_pointer`,
         //     so it is safe to turn back into a `P::DrvData`.

rust/kernel/power.rs

@@ -7,11 +7,6 @@
 use crate::{bindings, c_types, from_kernel_result, sync::Ref, types::PointerWrapper, Result};
 use core::{marker::PhantomData, ops::Deref};
 
-extern "C" {
-    #[allow(improper_ctypes)]
-    fn rust_helper_dev_get_drvdata(dev: *mut bindings::device) -> *mut c_types::c_void;
-}
-
 /// Corresponds to the kernel's `struct dev_pm_ops`.
 ///
 /// It is meant to be implemented by drivers that support power-management operations.
@@ -47,7 +42,7 @@ macro_rules! pm_callback {
         ) -> c_types::c_int {
             from_kernel_result! {
                 // SAFETY: `dev` is valid as it was passed in by the C portion.
-                let ptr = unsafe { rust_helper_dev_get_drvdata(dev) };
+                let ptr = unsafe { bindings::dev_get_drvdata(dev) };
                 // SAFETY: By the safety requirements of `OpsTable::build`, we know that `ptr` came
                 // from a previous call to `T::Data::into_pointer`.
                 let data = unsafe { T::Data::borrow(ptr) };

rust/kernel/rbtree.rs

@@ -16,14 +16,6 @@ use core::{
     ptr::{addr_of_mut, NonNull},
 };
 
-extern "C" {
-    fn rust_helper_rb_link_node(
-        node: *mut bindings::rb_node,
-        parent: *const bindings::rb_node,
-        rb_link: *mut *mut bindings::rb_node,
-    );
-}
-
 struct Node<K, V> {
     links: bindings::rb_node,
     key: K,
@@ -289,7 +281,7 @@ impl<K, V> RBTree<K, V> {
         // "forgot" it with `Box::into_raw`.
         // SAFETY: All pointers are non-null and valid (`*new_link` is null, but `new_link` is a
         // mutable reference).
-        unsafe { rust_helper_rb_link_node(node_links, parent, new_link) };
+        unsafe { bindings::rb_link_node(node_links, parent, new_link) };
 
         // SAFETY: All pointers are valid. `node` has just been inserted into the tree.
         unsafe { bindings::rb_insert_color(node_links, &mut self.root) };