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