Merge pull request #800 from ojeda/core_ffi

Take advantage of `feature(core_ffi_c)` and `feature(c_size_t)`

Author: ojeda

rust/Makefile

@@ -297,7 +297,7 @@ bindgen_c_flags_final = $(bindgen_c_flags_lto)
 quiet_cmd_bindgen = BINDGEN $@
       cmd_bindgen = \
 	$(BINDGEN) $< $(bindgen_target_flags) \
-		--use-core --with-derive-default --ctypes-prefix c_types \
+		--use-core --with-derive-default --ctypes-prefix core::ffi \
 		--no-debug '.*' \
 		--size_t-is-usize -o $@ -- $(bindgen_c_flags_final) -DMODULE \
 		$(bindgen_target_cflags) $(bindgen_target_extra)

rust/kernel/allocator.rs

@@ -6,7 +6,6 @@ use core::alloc::{GlobalAlloc, Layout};
 use core::ptr;
 
 use crate::bindings;
-use crate::c_types;
 
 struct KernelAllocator;
 
@@ -19,7 +18,7 @@ unsafe impl GlobalAlloc for KernelAllocator {
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
         unsafe {
-            bindings::kfree(ptr as *const c_types::c_void);
+            bindings::kfree(ptr as *const core::ffi::c_void);
         }
     }
 }
@@ -39,14 +38,14 @@ fn __rust_alloc(size: usize, _align: usize) -> *mut u8 {
 
 #[no_mangle]
 fn __rust_dealloc(ptr: *mut u8, _size: usize, _align: usize) {
-    unsafe { bindings::kfree(ptr as *const c_types::c_void) };
+    unsafe { bindings::kfree(ptr as *const core::ffi::c_void) };
 }
 
 #[no_mangle]
 fn __rust_realloc(ptr: *mut u8, _old_size: usize, _align: usize, new_size: usize) -> *mut u8 {
     unsafe {
         bindings::krealloc(
-            ptr as *const c_types::c_void,
+            ptr as *const core::ffi::c_void,
             new_size,
             bindings::GFP_KERNEL,
         ) as *mut u8

rust/kernel/amba.rs

@@ -5,8 +5,8 @@
 //! C header: [`include/linux/amba/bus.h`](../../../../include/linux/amba/bus.h)
 
 use crate::{
-    bindings, c_types, device, driver, error::from_kernel_result, io_mem::Resource, power,
-    str::CStr, to_result, types::PointerWrapper, Result, ThisModule,
+    bindings, device, driver, error::from_kernel_result, io_mem::Resource, power, str::CStr,
+    to_result, types::PointerWrapper, Result, ThisModule,
 };
 
 /// A registration of an amba driver.
@@ -108,7 +108,7 @@ impl<T: Driver> driver::DriverOps for Adapter<T> {
 unsafe extern "C" fn probe_callback<T: Driver>(
     adev: *mut bindings::amba_device,
     aid: *const bindings::amba_id,
-) -> c_types::c_int {
+) -> core::ffi::c_int {
     from_kernel_result! {
         // SAFETY: `adev` is valid by the contract with the C code. `dev` is alive only for the
         // duration of this call, so it is guaranteed to remain alive for the lifetime of `dev`.

rust/kernel/bindings.rs

@@ -22,7 +22,6 @@ mod bindings_raw {
     // Use glob import here to expose all helpers.
     // Symbols defined within the module will take precedence to the glob import.
     pub use super::bindings_helper::*;
-    use crate::c_types;
     include!(concat!(env!("OBJTREE"), "/rust/bindings_generated.rs"));
 }
 
@@ -33,7 +32,6 @@ mod bindings_raw {
 mod bindings_helper {
     // Import the generated bindings for types.
     use super::bindings_raw::*;
-    use crate::c_types;
     include!(concat!(
         env!("OBJTREE"),
         "/rust/bindings_helpers_generated.rs"

rust/kernel/c_types.rs

@@ -14,7 +14,6 @@ use core::marker::PhantomPinned;
 use core::pin::Pin;
 
 use crate::bindings;
-use crate::c_types;
 use crate::error::{code::*, Error, Result};
 use crate::file;
 use crate::str::CStr;
@@ -53,7 +52,7 @@ impl Cdev {
         Ok(Self(cdev))
     }
 
-    fn add(&mut self, dev: bindings::dev_t, count: c_types::c_uint) -> Result {
+    fn add(&mut self, dev: bindings::dev_t, count: core::ffi::c_uint) -> Result {
         // SAFETY: According to the type invariants:
         //   - [`self.0`] can be safely passed to [`bindings::cdev_add`].
         //   - [`(*self.0).ops`] will live at least as long as [`self.0`].

rust/kernel/chrdev.rs

@@ -21,7 +21,7 @@ use core::{
 };
 
 #[cfg(CONFIG_PRINTK)]
-use crate::{c_str, c_types};
+use crate::c_str;
 
 /// A raw device.
 ///
@@ -149,10 +149,10 @@ pub unsafe trait RawDevice {
         #[cfg(CONFIG_PRINTK)]
         unsafe {
             bindings::_dev_printk(
-                klevel as *const _ as *const c_types::c_char,
+                klevel as *const _ as *const core::ffi::c_char,
                 self.raw_device(),
                 c_str!("%pA").as_char_ptr(),
-                &msg as *const _ as *const c_types::c_void,
+                &msg as *const _ as *const core::ffi::c_void,
             )
         };
     }

rust/kernel/device.rs

@@ -4,8 +4,8 @@
 //!
 //! C header: [`include/uapi/asm-generic/errno-base.h`](../../../include/uapi/asm-generic/errno-base.h)
 
+use crate::bindings;
 use crate::str::CStr;
-use crate::{bindings, c_types};
 use alloc::{
     alloc::{AllocError, LayoutError},
     collections::TryReserveError,
@@ -315,14 +315,14 @@ pub mod code {
 ///
 /// The value is a valid `errno` (i.e. `>= -MAX_ERRNO && < 0`).
 #[derive(Clone, Copy, PartialEq, Eq)]
-pub struct Error(c_types::c_int);
+pub struct Error(core::ffi::c_int);
 
 impl Error {
     /// Creates an [`Error`] from a kernel error code.
     ///
     /// It is a bug to pass an out-of-range `errno`. `EINVAL` would
     /// be returned in such a case.
-    pub(crate) fn from_kernel_errno(errno: c_types::c_int) -> Error {
+    pub(crate) fn from_kernel_errno(errno: core::ffi::c_int) -> Error {
         if errno < -(bindings::MAX_ERRNO as i32) || errno >= 0 {
             // TODO: Make it a `WARN_ONCE` once available.
             crate::pr_warn!(
@@ -342,14 +342,14 @@ impl Error {
     /// # Safety
     ///
     /// `errno` must be within error code range (i.e. `>= -MAX_ERRNO && < 0`).
-    pub(crate) unsafe fn from_kernel_errno_unchecked(errno: c_types::c_int) -> Error {
+    pub(crate) unsafe fn from_kernel_errno_unchecked(errno: core::ffi::c_int) -> Error {
         // INVARIANT: The contract ensures the type invariant
         // will hold.
         Error(errno)
     }
 
     /// Returns the kernel error code.
-    pub fn to_kernel_errno(self) -> c_types::c_int {
+    pub fn to_kernel_errno(self) -> core::ffi::c_int {
         self.0
     }
 
@@ -482,11 +482,10 @@ where
 ///
 /// ```ignore
 /// # use kernel::from_kernel_result;
-/// # use kernel::c_types;
 /// # use kernel::bindings;
 /// unsafe extern "C" fn probe_callback(
 ///     pdev: *mut bindings::platform_device,
-/// ) -> c_types::c_int {
+/// ) -> core::ffi::c_int {
 ///     from_kernel_result! {
 ///         let ptr = devm_alloc(pdev)?;
 ///         bindings::platform_set_drvdata(pdev, ptr);
@@ -515,12 +514,11 @@ pub(crate) use from_kernel_result;
 ///
 /// ```ignore
 /// # use kernel::from_kernel_err_ptr;
-/// # use kernel::c_types;
 /// # use kernel::bindings;
 /// fn devm_platform_ioremap_resource(
 ///     pdev: &mut PlatformDevice,
 ///     index: u32,
-/// ) -> Result<*mut c_types::c_void> {
+/// ) -> Result<*mut core::ffi::c_void> {
 ///     // SAFETY: FFI call.
 ///     unsafe {
 ///         from_kernel_err_ptr(bindings::devm_platform_ioremap_resource(
@@ -533,8 +531,8 @@ pub(crate) use 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> {
-    // CAST: Casting a pointer to `*const c_types::c_void` is always valid.
-    let const_ptr: *const c_types::c_void = ptr.cast();
+    // CAST: Casting a pointer to `*const core::ffi::c_void` is always valid.
+    let const_ptr: *const core::ffi::c_void = ptr.cast();
     // SAFETY: The FFI function does not deref the pointer.
     if unsafe { bindings::IS_ERR(const_ptr) } {
         // SAFETY: The FFI function does not deref the pointer.
@@ -555,7 +553,7 @@ pub(crate) fn from_kernel_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
 
 /// 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() -> c_types::c_int) -> Result {
+pub fn to_result(func: impl FnOnce() -> core::ffi::c_int) -> Result {
     let err = func();
     if err < 0 {
         Err(Error::from_kernel_errno(err))