rust: kernel: use core::ffi instead of kernel::c_types

Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Author: ojeda

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/chrdev.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/device.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/error.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))

rust/kernel/file.rs

@@ -6,7 +6,7 @@
 //! [`include/linux/file.h`](../../../../include/linux/file.h)
 
 use crate::{
-    bindings, c_types,
+    bindings,
     cred::Credential,
     error::{code::*, from_kernel_result, Error, Result},
     io_buffer::{IoBufferReader, IoBufferWriter},
@@ -216,7 +216,7 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
     unsafe extern "C" fn open_callback(
         inode: *mut bindings::inode,
         file: *mut bindings::file,
-    ) -> c_types::c_int {
+    ) -> core::ffi::c_int {
         from_kernel_result! {
             // SAFETY: `A::convert` must return a valid non-null pointer that
             // should point to data in the inode or file that lives longer
@@ -233,19 +233,19 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
             // for implementers of the file operations (no other C code accesses
             // it), so we know that there are no concurrent threads/CPUs accessing
             // it (it's not visible to any other Rust code).
-            unsafe { (*file).private_data = ptr as *mut c_types::c_void };
+            unsafe { (*file).private_data = ptr as *mut core::ffi::c_void };
             Ok(0)
         }
     }
 
     unsafe extern "C" fn read_callback(
         file: *mut bindings::file,
-        buf: *mut c_types::c_char,
-        len: c_types::c_size_t,
+        buf: *mut core::ffi::c_char,
+        len: core::ffi::c_size_t,
         offset: *mut bindings::loff_t,
-    ) -> c_types::c_ssize_t {
+    ) -> core::ffi::c_ssize_t {
         from_kernel_result! {
-            let mut data = unsafe { UserSlicePtr::new(buf as *mut c_types::c_void, len).writer() };
+            let mut data = unsafe { UserSlicePtr::new(buf as *mut core::ffi::c_void, len).writer() };
             // SAFETY: `private_data` was initialised by `open_callback` with a value returned by
             // `T::Data::into_pointer`. `T::Data::from_pointer` is only called by the
             // `release` callback, which the C API guarantees that will be called only when all
@@ -288,12 +288,12 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
 
     unsafe extern "C" fn write_callback(
         file: *mut bindings::file,
-        buf: *const c_types::c_char,
-        len: c_types::c_size_t,
+        buf: *const core::ffi::c_char,
+        len: core::ffi::c_size_t,
         offset: *mut bindings::loff_t,
-    ) -> c_types::c_ssize_t {
+    ) -> core::ffi::c_ssize_t {
         from_kernel_result! {
-            let mut data = unsafe { UserSlicePtr::new(buf as *mut c_types::c_void, len).reader() };
+            let mut data = unsafe { UserSlicePtr::new(buf as *mut core::ffi::c_void, len).reader() };
             // SAFETY: `private_data` was initialised by `open_callback` with a value returned by
             // `T::Data::into_pointer`. `T::Data::from_pointer` is only called by the
             // `release` callback, which the C API guarantees that will be called only when all
@@ -337,7 +337,7 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
     unsafe extern "C" fn release_callback(
         _inode: *mut bindings::inode,
         file: *mut bindings::file,
-    ) -> c_types::c_int {
+    ) -> core::ffi::c_int {
         let ptr = mem::replace(unsafe { &mut (*file).private_data }, ptr::null_mut());
         T::release(unsafe { T::Data::from_pointer(ptr as _) }, unsafe {
             File::from_ptr(file)
@@ -348,7 +348,7 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
     unsafe extern "C" fn llseek_callback(
         file: *mut bindings::file,
         offset: bindings::loff_t,
-        whence: c_types::c_int,
+        whence: core::ffi::c_int,
     ) -> bindings::loff_t {
         from_kernel_result! {
             let off = match whence as u32 {
@@ -370,9 +370,9 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
 
     unsafe extern "C" fn unlocked_ioctl_callback(
         file: *mut bindings::file,
-        cmd: c_types::c_uint,
-        arg: c_types::c_ulong,
-    ) -> c_types::c_long {
+        cmd: core::ffi::c_uint,
+        arg: core::ffi::c_ulong,
+    ) -> core::ffi::c_long {
         from_kernel_result! {
             // SAFETY: `private_data` was initialised by `open_callback` with a value returned by
             // `T::Data::into_pointer`. `T::Data::from_pointer` is only called by the
@@ -388,9 +388,9 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
 
     unsafe extern "C" fn compat_ioctl_callback(
         file: *mut bindings::file,
-        cmd: c_types::c_uint,
-        arg: c_types::c_ulong,
-    ) -> c_types::c_long {
+        cmd: core::ffi::c_uint,
+        arg: core::ffi::c_ulong,
+    ) -> core::ffi::c_long {
         from_kernel_result! {
             // SAFETY: `private_data` was initialised by `open_callback` with a value returned by
             // `T::Data::into_pointer`. `T::Data::from_pointer` is only called by the
@@ -407,7 +407,7 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
     unsafe extern "C" fn mmap_callback(
         file: *mut bindings::file,
         vma: *mut bindings::vm_area_struct,
-    ) -> c_types::c_int {
+    ) -> core::ffi::c_int {
         from_kernel_result! {
             // SAFETY: `private_data` was initialised by `open_callback` with a value returned by
             // `T::Data::into_pointer`. `T::Data::from_pointer` is only called by the
@@ -431,8 +431,8 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
         file: *mut bindings::file,
         start: bindings::loff_t,
         end: bindings::loff_t,
-        datasync: c_types::c_int,
-    ) -> c_types::c_int {
+        datasync: core::ffi::c_int,
+    ) -> core::ffi::c_int {
         from_kernel_result! {
             let start = start.try_into()?;
             let end = end.try_into()?;

rust/kernel/gpio.rs

@@ -5,8 +5,8 @@
 //! C header: [`include/linux/gpio/driver.h`](../../../../include/linux/gpio/driver.h)
 
 use crate::{
-    bindings, c_types, device, error::code::*, error::from_kernel_result, types::PointerWrapper,
-    Error, Result,
+    bindings, device, error::code::*, error::from_kernel_result, types::PointerWrapper, Error,
+    Result,
 };
 use core::{
     cell::UnsafeCell,
@@ -249,8 +249,8 @@ impl<T: Chip> Drop for Registration<T> {
 
 unsafe extern "C" fn get_direction_callback<T: Chip>(
     gc: *mut bindings::gpio_chip,
-    offset: c_types::c_uint,
-) -> c_types::c_int {
+    offset: core::ffi::c_uint,
+) -> core::ffi::c_int {
     from_kernel_result! {
         // SAFETY: The value stored as chip data was returned by `into_pointer` during registration.
         let data = unsafe { T::Data::borrow(bindings::gpiochip_get_data(gc)) };
@@ -260,8 +260,8 @@ unsafe extern "C" fn get_direction_callback<T: Chip>(
 
 unsafe extern "C" fn direction_input_callback<T: Chip>(
     gc: *mut bindings::gpio_chip,
-    offset: c_types::c_uint,
-) -> c_types::c_int {
+    offset: core::ffi::c_uint,
+) -> core::ffi::c_int {
     from_kernel_result! {
         // SAFETY: The value stored as chip data was returned by `into_pointer` during registration.
         let data = unsafe { T::Data::borrow(bindings::gpiochip_get_data(gc)) };
@@ -272,9 +272,9 @@ unsafe extern "C" fn direction_input_callback<T: Chip>(
 
 unsafe extern "C" fn direction_output_callback<T: Chip>(
     gc: *mut bindings::gpio_chip,
-    offset: c_types::c_uint,
-    value: c_types::c_int,
-) -> c_types::c_int {
+    offset: core::ffi::c_uint,
+    value: core::ffi::c_int,
+) -> core::ffi::c_int {
     from_kernel_result! {
         // SAFETY: The value stored as chip data was returned by `into_pointer` during registration.
         let data = unsafe { T::Data::borrow(bindings::gpiochip_get_data(gc)) };
@@ -285,8 +285,8 @@ unsafe extern "C" fn direction_output_callback<T: Chip>(
 
 unsafe extern "C" fn get_callback<T: Chip>(
     gc: *mut bindings::gpio_chip,
-    offset: c_types::c_uint,
-) -> c_types::c_int {
+    offset: core::ffi::c_uint,
+) -> core::ffi::c_int {
     from_kernel_result! {
         // SAFETY: The value stored as chip data was returned by `into_pointer` during registration.
         let data = unsafe { T::Data::borrow(bindings::gpiochip_get_data(gc)) };
@@ -297,8 +297,8 @@ unsafe extern "C" fn get_callback<T: Chip>(
 
 unsafe extern "C" fn set_callback<T: Chip>(
     gc: *mut bindings::gpio_chip,
-    offset: c_types::c_uint,
-    value: c_types::c_int,
+    offset: core::ffi::c_uint,
+    value: core::ffi::c_int,
 ) {
     // SAFETY: The value stored as chip data was returned by `into_pointer` during registration.
     let data = unsafe { T::Data::borrow(bindings::gpiochip_get_data(gc)) };