rust/kernel/error.rs

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 //! Kernel errors.
   4 //!
   5 //! C header: [`include/uapi/asm-generic/errno-base.h`](srctree/include/uapi/asm-generic/errno-base.h)
   6
   7 use crate::{alloc::AllocError, str::CStr};
   8
   9 use core::alloc::LayoutError;
  10
  11 use core::fmt;
  12 use core::num::NonZeroI32;
  13 use core::num::TryFromIntError;
  14 use core::str::Utf8Error;
  15
  16 /// Contains the C-compatible error codes.
  17 #[rustfmt::skip]
  18 pub mod code {
  19     macro_rules! declare_err {
  20         ($err:tt $(,)? $($doc:expr),+) => {
  21             $(
  22             #[doc = $doc]
  23             )*
  24             pub const $err: super::Error =
  25                 match super::Error::try_from_errno(-(crate::bindings::$err as i32)) {
  26                     Some(err) => err,
  27                     None => panic!("Invalid errno in `declare_err!`"),
  28                 };
  29         };
  30     }
  31
  32     declare_err!(EPERM, "Operation not permitted.");
  33     declare_err!(ENOENT, "No such file or directory.");
  34     declare_err!(ESRCH, "No such process.");
  35     declare_err!(EINTR, "Interrupted system call.");
  36     declare_err!(EIO, "I/O error.");
  37     declare_err!(ENXIO, "No such device or address.");
  38     declare_err!(E2BIG, "Argument list too long.");
  39     declare_err!(ENOEXEC, "Exec format error.");
  40     declare_err!(EBADF, "Bad file number.");
  41     declare_err!(ECHILD, "No child processes.");
  42     declare_err!(EAGAIN, "Try again.");
  43     declare_err!(ENOMEM, "Out of memory.");
  44     declare_err!(EACCES, "Permission denied.");
  45     declare_err!(EFAULT, "Bad address.");
  46     declare_err!(ENOTBLK, "Block device required.");
  47     declare_err!(EBUSY, "Device or resource busy.");
  48     declare_err!(EEXIST, "File exists.");
  49     declare_err!(EXDEV, "Cross-device link.");
  50     declare_err!(ENODEV, "No such device.");
  51     declare_err!(ENOTDIR, "Not a directory.");
  52     declare_err!(EISDIR, "Is a directory.");
  53     declare_err!(EINVAL, "Invalid argument.");
  54     declare_err!(ENFILE, "File table overflow.");
  55     declare_err!(EMFILE, "Too many open files.");
  56     declare_err!(ENOTTY, "Not a typewriter.");
  57     declare_err!(ETXTBSY, "Text file busy.");
  58     declare_err!(EFBIG, "File too large.");
  59     declare_err!(ENOSPC, "No space left on device.");
  60     declare_err!(ESPIPE, "Illegal seek.");
  61     declare_err!(EROFS, "Read-only file system.");
  62     declare_err!(EMLINK, "Too many links.");
  63     declare_err!(EPIPE, "Broken pipe.");
  64     declare_err!(EDOM, "Math argument out of domain of func.");
  65     declare_err!(ERANGE, "Math result not representable.");
  66     declare_err!(ERESTARTSYS, "Restart the system call.");
  67     declare_err!(ERESTARTNOINTR, "System call was interrupted by a signal and will be restarted.");
  68     declare_err!(ERESTARTNOHAND, "Restart if no handler.");
  69     declare_err!(ENOIOCTLCMD, "No ioctl command.");
  70     declare_err!(ERESTART_RESTARTBLOCK, "Restart by calling sys_restart_syscall.");
  71     declare_err!(EPROBE_DEFER, "Driver requests probe retry.");
  72     declare_err!(EOPENSTALE, "Open found a stale dentry.");
  73     declare_err!(ENOPARAM, "Parameter not supported.");
  74     declare_err!(EBADHANDLE, "Illegal NFS file handle.");
  75     declare_err!(ENOTSYNC, "Update synchronization mismatch.");
  76     declare_err!(EBADCOOKIE, "Cookie is stale.");
  77     declare_err!(ENOTSUPP, "Operation is not supported.");
  78     declare_err!(ETOOSMALL, "Buffer or request is too small.");
  79     declare_err!(ESERVERFAULT, "An untranslatable error occurred.");
  80     declare_err!(EBADTYPE, "Type not supported by server.");
  81     declare_err!(EJUKEBOX, "Request initiated, but will not complete before timeout.");
  82     declare_err!(EIOCBQUEUED, "iocb queued, will get completion event.");
  83     declare_err!(ERECALLCONFLICT, "Conflict with recalled state.");
  84     declare_err!(ENOGRACE, "NFS file lock reclaim refused.");
  85 }
  86
  87 /// Generic integer kernel error.
  88 ///
  89 /// The kernel defines a set of integer generic error codes based on C and
  90 /// POSIX ones. These codes may have a more specific meaning in some contexts.
  91 ///
  92 /// # Invariants
  93 ///
  94 /// The value is a valid `errno` (i.e. `>= -MAX_ERRNO && < 0`).
  95 #[derive(Clone, Copy, PartialEq, Eq)]
  96 pub struct Error(NonZeroI32);
  97
  98 impl Error {
  99     /// Creates an [`Error`] from a kernel error code.
 100     ///
 101     /// It is a bug to pass an out-of-range `errno`. `EINVAL` would
 102     /// be returned in such a case.
 103     pub fn from_errno(errno: crate::ffi::c_int) -> Error {
 104         if errno < -(bindings::MAX_ERRNO as i32) || errno >= 0 {
 105             // TODO: Make it a `WARN_ONCE` once available.
 106             crate::pr_warn!(
 107                 "attempted to create `Error` with out of range `errno`: {}",
 108                 errno
 109             );
 110             return code::EINVAL;
 111         }
 112
 113         // INVARIANT: The check above ensures the type invariant
 114         // will hold.
 115         // SAFETY: `errno` is checked above to be in a valid range.
 116         unsafe { Error::from_errno_unchecked(errno) }
 117     }
 118
 119     /// Creates an [`Error`] from a kernel error code.
 120     ///
 121     /// Returns [`None`] if `errno` is out-of-range.
 122     const fn try_from_errno(errno: crate::ffi::c_int) -> Option<Error> {
 123         if errno < -(bindings::MAX_ERRNO as i32) || errno >= 0 {
 124             return None;
 125         }
 126
 127         // SAFETY: `errno` is checked above to be in a valid range.
 128         Some(unsafe { Error::from_errno_unchecked(errno) })
 129     }
 130
 131     /// Creates an [`Error`] from a kernel error code.
 132     ///
 133     /// # Safety
 134     ///
 135     /// `errno` must be within error code range (i.e. `>= -MAX_ERRNO && < 0`).
 136     const unsafe fn from_errno_unchecked(errno: crate::ffi::c_int) -> Error {
 137         // INVARIANT: The contract ensures the type invariant
 138         // will hold.
 139         // SAFETY: The caller guarantees `errno` is non-zero.
 140         Error(unsafe { NonZeroI32::new_unchecked(errno) })
 141     }
 142
 143     /// Returns the kernel error code.
 144     pub fn to_errno(self) -> crate::ffi::c_int {
 145         self.0.get()
 146     }
 147
 148     #[cfg(CONFIG_BLOCK)]
 149     pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
 150         // SAFETY: `self.0` is a valid error due to its invariant.
 151         unsafe { bindings::errno_to_blk_status(self.0.get()) }
 152     }
 153
 154     /// Returns the error encoded as a pointer.
 155     pub fn to_ptr<T>(self) -> *mut T {
 156         #[cfg_attr(target_pointer_width = "32", allow(clippy::useless_conversion))]
 157         // SAFETY: `self.0` is a valid error due to its invariant.
 158         unsafe {
 159             bindings::ERR_PTR(self.0.get().into()) as *mut _
 160         }
 161     }
 162
 163     /// Returns a string representing the error, if one exists.
 164     #[cfg(not(any(test, testlib)))]
 165     pub fn name(&self) -> Option<&'static CStr> {
 166         // SAFETY: Just an FFI call, there are no extra safety requirements.
 167         let ptr = unsafe { bindings::errname(-self.0.get()) };
 168         if ptr.is_null() {
 169             None
 170         } else {
 171             // SAFETY: The string returned by `errname` is static and `NUL`-terminated.
 172             Some(unsafe { CStr::from_char_ptr(ptr) })
 173         }
 174     }
 175
 176     /// Returns a string representing the error, if one exists.
 177     ///
 178     /// When `testlib` is configured, this always returns `None` to avoid the dependency on a
 179     /// kernel function so that tests that use this (e.g., by calling [`Result::unwrap`]) can still
 180     /// run in userspace.
 181     #[cfg(any(test, testlib))]
 182     pub fn name(&self) -> Option<&'static CStr> {
 183         None
 184     }
 185 }
 186
 187 impl fmt::Debug for Error {
 188     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 189         match self.name() {
 190             // Print out number if no name can be found.
 191             None => f.debug_tuple("Error").field(&-self.0).finish(),
 192             Some(name) => f
 193                 .debug_tuple(
 194                     // SAFETY: These strings are ASCII-only.
 195                     unsafe { core::str::from_utf8_unchecked(name) },
 196                 )
 197                 .finish(),
 198         }
 199     }
 200 }
 201
 202 impl From<AllocError> for Error {
 203     fn from(_: AllocError) -> Error {
 204         code::ENOMEM
 205     }
 206 }
 207
 208 impl From<TryFromIntError> for Error {
 209     fn from(_: TryFromIntError) -> Error {
 210         code::EINVAL
 211     }
 212 }
 213
 214 impl From<Utf8Error> for Error {
 215     fn from(_: Utf8Error) -> Error {
 216         code::EINVAL
 217     }
 218 }
 219
 220 impl From<LayoutError> for Error {
 221     fn from(_: LayoutError) -> Error {
 222         code::ENOMEM
 223     }
 224 }
 225
 226 impl From<core::fmt::Error> for Error {
 227     fn from(_: core::fmt::Error) -> Error {
 228         code::EINVAL
 229     }
 230 }
 231
 232 impl From<core::convert::Infallible> for Error {
 233     fn from(e: core::convert::Infallible) -> Error {
 234         match e {}
 235     }
 236 }
 237
 238 /// A [`Result`] with an [`Error`] error type.
 239 ///
 240 /// To be used as the return type for functions that may fail.
 241 ///
 242 /// # Error codes in C and Rust
 243 ///
 244 /// In C, it is common that functions indicate success or failure through
 245 /// their return value; modifying or returning extra data through non-`const`
 246 /// pointer parameters. In particular, in the kernel, functions that may fail
 247 /// typically return an `int` that represents a generic error code. We model
 248 /// those as [`Error`].
 249 ///
 250 /// In Rust, it is idiomatic to model functions that may fail as returning
 251 /// a [`Result`]. Since in the kernel many functions return an error code,
 252 /// [`Result`] is a type alias for a [`core::result::Result`] that uses
 253 /// [`Error`] as its error type.
 254 ///
 255 /// Note that even if a function does not return anything when it succeeds,
 256 /// it should still be modeled as returning a `Result` rather than
 257 /// just an [`Error`].
 258 pub type Result<T = (), E = Error> = core::result::Result<T, E>;
 259
 260 /// Converts an integer as returned by a C kernel function to an error if it's negative, and
 261 /// `Ok(())` otherwise.
 262 pub fn to_result(err: crate::ffi::c_int) -> Result {
 263     if err < 0 {
 264         Err(Error::from_errno(err))
 265     } else {
 266         Ok(())
 267     }
 268 }
 269
 270 /// Transform a kernel "error pointer" to a normal pointer.
 271 ///
 272 /// Some kernel C API functions return an "error pointer" which optionally
 273 /// embeds an `errno`. Callers are supposed to check the returned pointer
 274 /// for errors. This function performs the check and converts the "error pointer"
 275 /// to a normal pointer in an idiomatic fashion.
 276 ///
 277 /// # Examples
 278 ///
 279 /// ```ignore
 280 /// # use kernel::from_err_ptr;
 281 /// # use kernel::bindings;
 282 /// fn devm_platform_ioremap_resource(
 283 ///     pdev: &mut PlatformDevice,
 284 ///     index: u32,
 285 /// ) -> Result<*mut kernel::ffi::c_void> {
 286 ///     // SAFETY: `pdev` points to a valid platform device. There are no safety requirements
 287 ///     // on `index`.
 288 ///     from_err_ptr(unsafe { bindings::devm_platform_ioremap_resource(pdev.to_ptr(), index) })
 289 /// }
 290 /// ```
 291 pub fn from_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
 292     // CAST: Casting a pointer to `*const crate::ffi::c_void` is always valid.
 293     let const_ptr: *const crate::ffi::c_void = ptr.cast();
 294     // SAFETY: The FFI function does not deref the pointer.
 295     if unsafe { bindings::IS_ERR(const_ptr) } {
 296         // SAFETY: The FFI function does not deref the pointer.
 297         let err = unsafe { bindings::PTR_ERR(const_ptr) };
 298
 299         #[allow(clippy::unnecessary_cast)]
 300         // CAST: If `IS_ERR()` returns `true`,
 301         // then `PTR_ERR()` is guaranteed to return a
 302         // negative value greater-or-equal to `-bindings::MAX_ERRNO`,
 303         // which always fits in an `i16`, as per the invariant above.
 304         // And an `i16` always fits in an `i32`. So casting `err` to
 305         // an `i32` can never overflow, and is always valid.
 306         //
 307         // SAFETY: `IS_ERR()` ensures `err` is a
 308         // negative value greater-or-equal to `-bindings::MAX_ERRNO`.
 309         return Err(unsafe { Error::from_errno_unchecked(err as crate::ffi::c_int) });
 310     }
 311     Ok(ptr)
 312 }
 313
 314 /// Calls a closure returning a [`crate::error::Result<T>`] and converts the result to
 315 /// a C integer result.
 316 ///
 317 /// This is useful when calling Rust functions that return [`crate::error::Result<T>`]
 318 /// from inside `extern "C"` functions that need to return an integer error result.
 319 ///
 320 /// `T` should be convertible from an `i16` via `From<i16>`.
 321 ///
 322 /// # Examples
 323 ///
 324 /// ```ignore
 325 /// # use kernel::from_result;
 326 /// # use kernel::bindings;
 327 /// unsafe extern "C" fn probe_callback(
 328 ///     pdev: *mut bindings::platform_device,
 329 /// ) -> kernel::ffi::c_int {
 330 ///     from_result(|| {
 331 ///         let ptr = devm_alloc(pdev)?;
 332 ///         bindings::platform_set_drvdata(pdev, ptr);
 333 ///         Ok(0)
 334 ///     })
 335 /// }
 336 /// ```
 337 pub fn from_result<T, F>(f: F) -> T
 338 where
 339     T: From<i16>,
 340     F: FnOnce() -> Result<T>,
 341 {
 342     match f() {
 343         Ok(v) => v,
 344         // NO-OVERFLOW: negative `errno`s are no smaller than `-bindings::MAX_ERRNO`,
 345         // `-bindings::MAX_ERRNO` fits in an `i16` as per invariant above,
 346         // therefore a negative `errno` always fits in an `i16` and will not overflow.
 347         Err(e) => T::from(e.to_errno() as i16),
 348     }
 349 }
 350
 351 /// Error message for calling a default function of a [`#[vtable]`](macros::vtable) trait.
 352 pub const VTABLE_DEFAULT_ERROR: &str =
 353     "This function must not be called, see the #[vtable] documentation.";