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//! C header: [`include/uapi/asm-generic/errno.h`](srctree/include/uapi/asm-generic/errno.h)\
  7//! C header: [`include/linux/errno.h`](srctree/include/linux/errno.h)
  8
  9use crate::{
 10    alloc::{layout::LayoutError, AllocError},
 11    fmt,
 12    str::CStr,
 13};
 14
 15use core::num::NonZeroI32;
 16use core::num::TryFromIntError;
 17use core::str::Utf8Error;
 18
 19/// Contains the C-compatible error codes.
 20#[rustfmt::skip]
 21pub mod code {
 22    macro_rules! declare_err {
 23        ($err:tt $(,)? $($doc:expr),+) => {
 24            $(
 25            #[doc = $doc]
 26            )*
 27            pub const $err: super::Error =
 28                match super::Error::try_from_errno(-(crate::bindings::$err as i32)) {
 29                    Some(err) => err,
 30                    None => panic!("Invalid errno in `declare_err!`"),
 31                };
 32        };
 33    }
 34
 35    declare_err!(EPERM, "Operation not permitted.");
 36    declare_err!(ENOENT, "No such file or directory.");
 37    declare_err!(ESRCH, "No such process.");
 38    declare_err!(EINTR, "Interrupted system call.");
 39    declare_err!(EIO, "I/O error.");
 40    declare_err!(ENXIO, "No such device or address.");
 41    declare_err!(E2BIG, "Argument list too long.");
 42    declare_err!(ENOEXEC, "Exec format error.");
 43    declare_err!(EBADF, "Bad file number.");
 44    declare_err!(ECHILD, "No child processes.");
 45    declare_err!(EAGAIN, "Try again.");
 46    declare_err!(ENOMEM, "Out of memory.");
 47    declare_err!(EACCES, "Permission denied.");
 48    declare_err!(EFAULT, "Bad address.");
 49    declare_err!(ENOTBLK, "Block device required.");
 50    declare_err!(EBUSY, "Device or resource busy.");
 51    declare_err!(EEXIST, "File exists.");
 52    declare_err!(EXDEV, "Cross-device link.");
 53    declare_err!(ENODEV, "No such device.");
 54    declare_err!(ENOTDIR, "Not a directory.");
 55    declare_err!(EISDIR, "Is a directory.");
 56    declare_err!(EINVAL, "Invalid argument.");
 57    declare_err!(ENFILE, "File table overflow.");
 58    declare_err!(EMFILE, "Too many open files.");
 59    declare_err!(ENOTTY, "Not a typewriter.");
 60    declare_err!(ETXTBSY, "Text file busy.");
 61    declare_err!(EFBIG, "File too large.");
 62    declare_err!(ENOSPC, "No space left on device.");
 63    declare_err!(ESPIPE, "Illegal seek.");
 64    declare_err!(EROFS, "Read-only file system.");
 65    declare_err!(EMLINK, "Too many links.");
 66    declare_err!(EPIPE, "Broken pipe.");
 67    declare_err!(EDOM, "Math argument out of domain of func.");
 68    declare_err!(ERANGE, "Math result not representable.");
 69    declare_err!(EOVERFLOW, "Value too large for defined data type.");
 70    declare_err!(ETIMEDOUT, "Connection timed out.");
 71    declare_err!(ERESTARTSYS, "Restart the system call.");
 72    declare_err!(ERESTARTNOINTR, "System call was interrupted by a signal and will be restarted.");
 73    declare_err!(ERESTARTNOHAND, "Restart if no handler.");
 74    declare_err!(ENOIOCTLCMD, "No ioctl command.");
 75    declare_err!(ERESTART_RESTARTBLOCK, "Restart by calling sys_restart_syscall.");
 76    declare_err!(EPROBE_DEFER, "Driver requests probe retry.");
 77    declare_err!(EOPENSTALE, "Open found a stale dentry.");
 78    declare_err!(ENOPARAM, "Parameter not supported.");
 79    declare_err!(EBADHANDLE, "Illegal NFS file handle.");
 80    declare_err!(ENOTSYNC, "Update synchronization mismatch.");
 81    declare_err!(EBADCOOKIE, "Cookie is stale.");
 82    declare_err!(ENOTSUPP, "Operation is not supported.");
 83    declare_err!(ETOOSMALL, "Buffer or request is too small.");
 84    declare_err!(ESERVERFAULT, "An untranslatable error occurred.");
 85    declare_err!(EBADTYPE, "Type not supported by server.");
 86    declare_err!(EJUKEBOX, "Request initiated, but will not complete before timeout.");
 87    declare_err!(EIOCBQUEUED, "iocb queued, will get completion event.");
 88    declare_err!(ERECALLCONFLICT, "Conflict with recalled state.");
 89    declare_err!(ENOGRACE, "NFS file lock reclaim refused.");
 90}
 91
 92/// Generic integer kernel error.
 93///
 94/// The kernel defines a set of integer generic error codes based on C and
 95/// POSIX ones. These codes may have a more specific meaning in some contexts.
 96///
 97/// # Invariants
 98///
 99/// The value is a valid `errno` (i.e. `>= -MAX_ERRNO && < 0`).
100#[derive(Clone, Copy, PartialEq, Eq)]
101pub struct Error(NonZeroI32);
102
103impl Error {
104    /// Creates an [`Error`] from a kernel error code.
105    ///
106    /// `errno` must be within error code range (i.e. `>= -MAX_ERRNO && < 0`).
107    ///
108    /// It is a bug to pass an out-of-range `errno`. [`code::EINVAL`] is returned in such a case.
109    ///
110    /// # Examples
111    ///
112    /// ```
113    /// assert_eq!(Error::from_errno(-1), EPERM);
114    /// assert_eq!(Error::from_errno(-2), ENOENT);
115    /// ```
116    ///
117    /// The following calls are considered a bug:
118    ///
119    /// ```
120    /// assert_eq!(Error::from_errno(0), EINVAL);
121    /// assert_eq!(Error::from_errno(-1000000), EINVAL);
122    /// ```
123    pub fn from_errno(errno: crate::ffi::c_int) -> Error {
124        if let Some(error) = Self::try_from_errno(errno) {
125            error
126        } else {
127            // TODO: Make it a `WARN_ONCE` once available.
128            crate::pr_warn!(
129                "attempted to create `Error` with out of range `errno`: {}\n",
130                errno
131            );
132            code::EINVAL
133        }
134    }
135
136    /// Creates an [`Error`] from a kernel error code.
137    ///
138    /// Returns [`None`] if `errno` is out-of-range.
139    const fn try_from_errno(errno: crate::ffi::c_int) -> Option<Error> {
140        if errno < -(bindings::MAX_ERRNO as i32) || errno >= 0 {
141            return None;
142        }
143
144        // SAFETY: `errno` is checked above to be in a valid range.
145        Some(unsafe { Error::from_errno_unchecked(errno) })
146    }
147
148    /// Creates an [`Error`] from a kernel error code.
149    ///
150    /// # Safety
151    ///
152    /// `errno` must be within error code range (i.e. `>= -MAX_ERRNO && < 0`).
153    const unsafe fn from_errno_unchecked(errno: crate::ffi::c_int) -> Error {
154        // INVARIANT: The contract ensures the type invariant
155        // will hold.
156        // SAFETY: The caller guarantees `errno` is non-zero.
157        Error(unsafe { NonZeroI32::new_unchecked(errno) })
158    }
159
160    /// Returns the kernel error code.
161    pub fn to_errno(self) -> crate::ffi::c_int {
162        self.0.get()
163    }
164
165    #[cfg(CONFIG_BLOCK)]
166    pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
167        // SAFETY: `self.0` is a valid error due to its invariant.
168        unsafe { bindings::errno_to_blk_status(self.0.get()) }
169    }
170
171    /// Returns the error encoded as a pointer.
172    pub fn to_ptr<T>(self) -> *mut T {
173        // SAFETY: `self.0` is a valid error due to its invariant.
174        unsafe { bindings::ERR_PTR(self.0.get() as crate::ffi::c_long).cast() }
175    }
176
177    /// Returns a string representing the error, if one exists.
178    #[cfg(not(testlib))]
179    pub fn name(&self) -> Option<&'static CStr> {
180        // SAFETY: Just an FFI call, there are no extra safety requirements.
181        let ptr = unsafe { bindings::errname(-self.0.get()) };
182        if ptr.is_null() {
183            None
184        } else {
185            use crate::str::CStrExt as _;
186
187            // SAFETY: The string returned by `errname` is static and `NUL`-terminated.
188            Some(unsafe { CStr::from_char_ptr(ptr) })
189        }
190    }
191
192    /// Returns a string representing the error, if one exists.
193    ///
194    /// When `testlib` is configured, this always returns `None` to avoid the dependency on a
195    /// kernel function so that tests that use this (e.g., by calling [`Result::unwrap`]) can still
196    /// run in userspace.
197    #[cfg(testlib)]
198    pub fn name(&self) -> Option<&'static CStr> {
199        None
200    }
201}
202
203impl fmt::Debug for Error {
204    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
205        match self.name() {
206            // Print out number if no name can be found.
207            None => f.debug_tuple("Error").field(&-self.0).finish(),
208            Some(name) => f
209                .debug_tuple(
210                    // SAFETY: These strings are ASCII-only.
211                    unsafe { core::str::from_utf8_unchecked(name.to_bytes()) },
212                )
213                .finish(),
214        }
215    }
216}
217
218impl From<AllocError> for Error {
219    fn from(_: AllocError) -> Error {
220        code::ENOMEM
221    }
222}
223
224impl From<TryFromIntError> for Error {
225    fn from(_: TryFromIntError) -> Error {
226        code::EINVAL
227    }
228}
229
230impl From<Utf8Error> for Error {
231    fn from(_: Utf8Error) -> Error {
232        code::EINVAL
233    }
234}
235
236impl From<LayoutError> for Error {
237    fn from(_: LayoutError) -> Error {
238        code::ENOMEM
239    }
240}
241
242impl From<fmt::Error> for Error {
243    fn from(_: fmt::Error) -> Error {
244        code::EINVAL
245    }
246}
247
248impl From<core::convert::Infallible> for Error {
249    fn from(e: core::convert::Infallible) -> Error {
250        match e {}
251    }
252}
253
254/// A [`Result`] with an [`Error`] error type.
255///
256/// To be used as the return type for functions that may fail.
257///
258/// # Error codes in C and Rust
259///
260/// In C, it is common that functions indicate success or failure through
261/// their return value; modifying or returning extra data through non-`const`
262/// pointer parameters. In particular, in the kernel, functions that may fail
263/// typically return an `int` that represents a generic error code. We model
264/// those as [`Error`].
265///
266/// In Rust, it is idiomatic to model functions that may fail as returning
267/// a [`Result`]. Since in the kernel many functions return an error code,
268/// [`Result`] is a type alias for a [`core::result::Result`] that uses
269/// [`Error`] as its error type.
270///
271/// Note that even if a function does not return anything when it succeeds,
272/// it should still be modeled as returning a [`Result`] rather than
273/// just an [`Error`].
274///
275/// Calling a function that returns [`Result`] forces the caller to handle
276/// the returned [`Result`].
277///
278/// This can be done "manually" by using [`match`]. Using [`match`] to decode
279/// the [`Result`] is similar to C where all the return value decoding and the
280/// error handling is done explicitly by writing handling code for each
281/// error to cover. Using [`match`] the error and success handling can be
282/// implemented in all detail as required. For example (inspired by
283/// [`samples/rust/rust_minimal.rs`]):
284///
285/// ```
286/// # #[allow(clippy::single_match)]
287/// fn example() -> Result {
288///     let mut numbers = KVec::new();
289///
290///     match numbers.push(72, GFP_KERNEL) {
291///         Err(e) => {
292///             pr_err!("Error pushing 72: {e:?}");
293///             return Err(e.into());
294///         }
295///         // Do nothing, continue.
296///         Ok(()) => (),
297///     }
298///
299///     match numbers.push(108, GFP_KERNEL) {
300///         Err(e) => {
301///             pr_err!("Error pushing 108: {e:?}");
302///             return Err(e.into());
303///         }
304///         // Do nothing, continue.
305///         Ok(()) => (),
306///     }
307///
308///     match numbers.push(200, GFP_KERNEL) {
309///         Err(e) => {
310///             pr_err!("Error pushing 200: {e:?}");
311///             return Err(e.into());
312///         }
313///         // Do nothing, continue.
314///         Ok(()) => (),
315///     }
316///
317///     Ok(())
318/// }
319/// # example()?;
320/// # Ok::<(), Error>(())
321/// ```
322///
323/// An alternative to be more concise is the [`if let`] syntax:
324///
325/// ```
326/// fn example() -> Result {
327///     let mut numbers = KVec::new();
328///
329///     if let Err(e) = numbers.push(72, GFP_KERNEL) {
330///         pr_err!("Error pushing 72: {e:?}");
331///         return Err(e.into());
332///     }
333///
334///     if let Err(e) = numbers.push(108, GFP_KERNEL) {
335///         pr_err!("Error pushing 108: {e:?}");
336///         return Err(e.into());
337///     }
338///
339///     if let Err(e) = numbers.push(200, GFP_KERNEL) {
340///         pr_err!("Error pushing 200: {e:?}");
341///         return Err(e.into());
342///     }
343///
344///     Ok(())
345/// }
346/// # example()?;
347/// # Ok::<(), Error>(())
348/// ```
349///
350/// Instead of these verbose [`match`]/[`if let`], the [`?`] operator can
351/// be used to handle the [`Result`]. Using the [`?`] operator is often
352/// the best choice to handle [`Result`] in a non-verbose way as done in
353/// [`samples/rust/rust_minimal.rs`]:
354///
355/// ```
356/// fn example() -> Result {
357///     let mut numbers = KVec::new();
358///
359///     numbers.push(72, GFP_KERNEL)?;
360///     numbers.push(108, GFP_KERNEL)?;
361///     numbers.push(200, GFP_KERNEL)?;
362///
363///     Ok(())
364/// }
365/// # example()?;
366/// # Ok::<(), Error>(())
367/// ```
368///
369/// Another possibility is to call [`unwrap()`](Result::unwrap) or
370/// [`expect()`](Result::expect). However, use of these functions is
371/// *heavily discouraged* in the kernel because they trigger a Rust
372/// [`panic!`] if an error happens, which may destabilize the system or
373/// entirely break it as a result -- just like the C [`BUG()`] macro.
374/// Please see the documentation for the C macro [`BUG()`] for guidance
375/// on when to use these functions.
376///
377/// Alternatively, depending on the use case, using [`unwrap_or()`],
378/// [`unwrap_or_else()`], [`unwrap_or_default()`] or [`unwrap_unchecked()`]
379/// might be an option, as well.
380///
381/// For even more details, please see the [Rust documentation].
382///
383/// [`match`]: https://doc.rust-lang.org/reference/expressions/match-expr.html
384/// [`samples/rust/rust_minimal.rs`]: srctree/samples/rust/rust_minimal.rs
385/// [`if let`]: https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions
386/// [`?`]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator
387/// [`unwrap()`]: Result::unwrap
388/// [`expect()`]: Result::expect
389/// [`BUG()`]: https://docs.kernel.org/process/deprecated.html#bug-and-bug-on
390/// [`unwrap_or()`]: Result::unwrap_or
391/// [`unwrap_or_else()`]: Result::unwrap_or_else
392/// [`unwrap_or_default()`]: Result::unwrap_or_default
393/// [`unwrap_unchecked()`]: Result::unwrap_unchecked
394/// [Rust documentation]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html
395pub type Result<T = (), E = Error> = core::result::Result<T, E>;
396
397/// Converts an integer as returned by a C kernel function to a [`Result`].
398///
399/// If the integer is negative, an [`Err`] with an [`Error`] as given by [`Error::from_errno`] is
400/// returned. This means the integer must be `>= -MAX_ERRNO`.
401///
402/// Otherwise, it returns [`Ok`].
403///
404/// It is a bug to pass an out-of-range negative integer. `Err(EINVAL)` is returned in such a case.
405///
406/// # Examples
407///
408/// This function may be used to easily perform early returns with the [`?`] operator when working
409/// with C APIs within Rust abstractions:
410///
411/// ```
412/// # use kernel::error::to_result;
413/// # mod bindings {
414/// #     #![expect(clippy::missing_safety_doc)]
415/// #     use kernel::prelude::*;
416/// #     pub(super) unsafe fn f1() -> c_int { 0 }
417/// #     pub(super) unsafe fn f2() -> c_int { EINVAL.to_errno() }
418/// # }
419/// fn f() -> Result {
420///     // SAFETY: ...
421///     to_result(unsafe { bindings::f1() })?;
422///
423///     // SAFETY: ...
424///     to_result(unsafe { bindings::f2() })?;
425///
426///     // ...
427///
428///     Ok(())
429/// }
430/// # assert_eq!(f(), Err(EINVAL));
431/// ```
432///
433/// [`?`]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator
434pub fn to_result(err: crate::ffi::c_int) -> Result {
435    if err < 0 {
436        Err(Error::from_errno(err))
437    } else {
438        Ok(())
439    }
440}
441
442/// Transform a kernel "error pointer" to a normal pointer.
443///
444/// Some kernel C API functions return an "error pointer" which optionally
445/// embeds an `errno`. Callers are supposed to check the returned pointer
446/// for errors. This function performs the check and converts the "error pointer"
447/// to a normal pointer in an idiomatic fashion.
448///
449/// # Examples
450///
451/// ```ignore
452/// # use kernel::from_err_ptr;
453/// # use kernel::bindings;
454/// fn devm_platform_ioremap_resource(
455///     pdev: &mut PlatformDevice,
456///     index: u32,
457/// ) -> Result<*mut kernel::ffi::c_void> {
458///     // SAFETY: `pdev` points to a valid platform device. There are no safety requirements
459///     // on `index`.
460///     from_err_ptr(unsafe { bindings::devm_platform_ioremap_resource(pdev.to_ptr(), index) })
461/// }
462/// ```
463pub fn from_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
464    // CAST: Casting a pointer to `*const crate::ffi::c_void` is always valid.
465    let const_ptr: *const crate::ffi::c_void = ptr.cast();
466    // SAFETY: The FFI function does not deref the pointer.
467    if unsafe { bindings::IS_ERR(const_ptr) } {
468        // SAFETY: The FFI function does not deref the pointer.
469        let err = unsafe { bindings::PTR_ERR(const_ptr) };
470
471        #[allow(clippy::unnecessary_cast)]
472        // CAST: If `IS_ERR()` returns `true`,
473        // then `PTR_ERR()` is guaranteed to return a
474        // negative value greater-or-equal to `-bindings::MAX_ERRNO`,
475        // which always fits in an `i16`, as per the invariant above.
476        // And an `i16` always fits in an `i32`. So casting `err` to
477        // an `i32` can never overflow, and is always valid.
478        //
479        // SAFETY: `IS_ERR()` ensures `err` is a
480        // negative value greater-or-equal to `-bindings::MAX_ERRNO`.
481        return Err(unsafe { Error::from_errno_unchecked(err as crate::ffi::c_int) });
482    }
483    Ok(ptr)
484}
485
486/// Calls a closure returning a [`crate::error::Result<T>`] and converts the result to
487/// a C integer result.
488///
489/// This is useful when calling Rust functions that return [`crate::error::Result<T>`]
490/// from inside `extern "C"` functions that need to return an integer error result.
491///
492/// `T` should be convertible from an `i16` via `From<i16>`.
493///
494/// # Examples
495///
496/// ```ignore
497/// # use kernel::from_result;
498/// # use kernel::bindings;
499/// unsafe extern "C" fn probe_callback(
500///     pdev: *mut bindings::platform_device,
501/// ) -> kernel::ffi::c_int {
502///     from_result(|| {
503///         let ptr = devm_alloc(pdev)?;
504///         bindings::platform_set_drvdata(pdev, ptr);
505///         Ok(0)
506///     })
507/// }
508/// ```
509pub fn from_result<T, F>(f: F) -> T
510where
511    T: From<i16>,
512    F: FnOnce() -> Result<T>,
513{
514    match f() {
515        Ok(v) => v,
516        // NO-OVERFLOW: negative `errno`s are no smaller than `-bindings::MAX_ERRNO`,
517        // `-bindings::MAX_ERRNO` fits in an `i16` as per invariant above,
518        // therefore a negative `errno` always fits in an `i16` and will not overflow.
519        Err(e) => T::from(e.to_errno() as i16),
520    }
521}
522
523/// Error message for calling a default function of a [`#[vtable]`](macros::vtable) trait.
524pub const VTABLE_DEFAULT_ERROR: &str =
525    "This function must not be called, see the #[vtable] documentation.";