rust/kernel: move from_kernel_result! macro to error.rs

rust/kernel/error.rs

@@ -6,6 +6,7 @@
 
 use crate::{bindings, c_types};
 use alloc::{alloc::AllocError, collections::TryReserveError};
+use core::convert::From;
 use core::{num::TryFromIntError, str::Utf8Error};
 
 /// Generic integer kernel error.
@@ -104,3 +105,50 @@ impl From<AllocError> for Error {
  Error::ENOMEM
  }
 }
+
+// # Invariant: `-bindings::MAX_ERRNO` fits in an `i16`.
+crate::static_assert!(bindings::MAX_ERRNO <= -(i16::MIN as i32) as u32);
+
+#[doc(hidden)]
+pub fn from_kernel_result_helper<T>(r: Result<T>) -> T
+where
+ T: From<i16>,
+{
+ match r {
+ Ok(v) => v,
+ // NO-OVERFLOW: negative `errno`s are no smaller than `-bindings::MAX_ERRNO`,
+ // `-bindings::MAX_ERRNO` fits in an `i16` as per invariant above,
+ // therefore a negative `errno` always fits in an `i16` and will not overflow.
+ Err(e) => T::from(e.to_kernel_errno() as i16),
+ }
+}
+
+/// Transforms a [`crate::error::Result<T>`] to a kernel C integer result.
+///
+/// This is useful when calling Rust functions that return [`crate::error::Result<T>`]
+/// from inside `extern "C"` functions that need to return an integer
+/// error result.
+///
+/// `T` should be convertible to an `i16` via `From<i16>`.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// unsafe extern "C" fn probe_callback(
+/// pdev: *mut bindings::platform_device,
+/// ) -> c_types::c_int {
+/// from_kernel_result! {
+/// let ptr = devm_alloc(pdev)?;
+/// rust_helper_platform_set_drvdata(pdev, ptr);
+/// Ok(0)
+/// }
+/// }
+/// ```
+#[macro_export]
+macro_rules! from_kernel_result {
+ ($($tt:tt)*) => {{
+ $crate::error::from_kernel_result_helper((|| {
+ $($tt)*
+ })())
+ }};
+}

rust/kernel/file_operations.rs

@@ -13,6 +13,7 @@ use crate::{
  bindings, c_types,
  error::{Error, Result},
  file::File,
+ from_kernel_result,
  io_buffer::{IoBufferReader, IoBufferWriter},
  iov_iter::IovIter,
  sync::CondVar,
@@ -78,25 +79,6 @@ pub enum SeekFrom {
  Current(i64),
 }
 
-fn from_kernel_result<T>(r: Result<T>) -> T
-where
- T: TryFrom<c_types::c_int>,
- T::Error: core::fmt::Debug,
-{
- match r {
- Ok(v) => v,
- Err(e) => T::try_from(e.to_kernel_errno()).unwrap(),
- }
-}
-
-macro_rules! from_kernel_result {
- ($($tt:tt)*) => {{
- from_kernel_result((|| {
- $($tt)*
- })())
- }};
-}
-
 unsafe extern "C" fn open_callback<A: FileOpenAdapter, T: FileOpener<A::Arg>>(
  inode: *mut bindings::inode,
  file: *mut bindings::file,