1//! The `rustix` `Errno` type.
2//!
3//! This type holds an OS error code, which conceptually corresponds to an
4//! `errno` value.
5//!
6//! # Safety
7//!
8//! Linux uses error codes in `-4095..0`; we use rustc attributes to describe
9//! this restricted range of values.
10#![allow(unsafe_code)]
11#![cfg_attr(not(rustc_attrs), allow(unused_unsafe))]
12
13use crate::backend::c;
14use crate::backend::fd::RawFd;
15use crate::backend::reg::{RetNumber, RetReg};
16use crate::io;
17use linux_raw_sys::errno;
18
19/// `errno`—An error code.
20///
21/// The error type for `rustix` APIs. This is similar to [`std::io::Error`],
22/// but only holds an OS error code, and no extra error value.
23///
24/// # References
25/// - [POSIX]
26/// - [Linux]
27/// - [Winsock]
28/// - [FreeBSD]
29/// - [NetBSD]
30/// - [OpenBSD]
31/// - [DragonFly BSD]
32/// - [illumos]
33/// - [glibc]
34///
35/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/errno.html
36/// [Linux]: https://man7.org/linux/man-pages/man3/errno.3.html
37/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
38/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?errno
39/// [NetBSD]: https://man.netbsd.org/errno.2
40/// [OpenBSD]: https://man.openbsd.org/errno.2
41/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=errno§ion=2
42/// [illumos]: https://illumos.org/man/3C/errno
43/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
44/// [`std::io::Error`]: Result
45#[repr(transparent)]
46#[doc(alias = "errno")]
47#[derive(Eq, PartialEq, Hash, Copy, Clone)]
48// Linux returns negated error codes, and we leave them in negated form, so
49// error codes are in `-4095..0`.
50#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_start(0xf001))]
51#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_end(0xffff))]
52pub struct Errno(u16);
53
54impl Errno {
55 /// Extract an `Errno` value from a `std::io::Error`.
56 ///
57 /// This isn't a `From` conversion because it's expected to be relatively
58 /// uncommon.
59 #[cfg(feature = "std")]
60 #[inline]
61 pub fn from_io_error(io_err: &std::io::Error) -> Option<Self> {
62 io_err.raw_os_error().and_then(|raw| {
63 // `std::io::Error` could theoretically have arbitrary OS error
64 // values, so check that they're in Linux's range.
65 if (1..4096).contains(&raw) {
66 Some(Self::from_errno(raw as u32))
67 } else {
68 None
69 }
70 })
71 }
72
73 /// Extract the raw OS error number from this error.
74 #[inline]
75 pub const fn raw_os_error(self) -> i32 {
76 (self.0 as i16 as i32).wrapping_neg()
77 }
78
79 /// Construct an `Errno` from a raw OS error number.
80 #[inline]
81 pub const fn from_raw_os_error(raw: i32) -> Self {
82 Self::from_errno(raw as u32)
83 }
84
85 /// Convert from a C `errno` value (which is positive) to an `Errno`.
86 const fn from_errno(raw: u32) -> Self {
87 // We store error values in negated form, so that we don't have to
88 // negate them after every syscall.
89 let encoded = raw.wrapping_neg() as u16;
90
91 // TODO: Use Range::contains, once that's `const`.
92 assert!(encoded >= 0xf001);
93
94 // SAFETY: Linux syscalls return negated error values in the range
95 // `-4095..0`, which we just asserted.
96 unsafe { Self(encoded) }
97 }
98}
99
100/// Check for an error from the result of a syscall which encodes a
101/// `c::c_int` on success.
102#[inline]
103pub(in crate::backend) fn try_decode_c_int<Num: RetNumber>(
104 raw: RetReg<Num>,
105) -> io::Result<c::c_int> {
106 if raw.is_in_range(-4095..0) {
107 // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
108 // in that range.
109 return Err(unsafe { Errno(raw.decode_error_code()) });
110 }
111
112 Ok(raw.decode_c_int())
113}
114
115/// Check for an error from the result of a syscall which encodes a
116/// `c::c_uint` on success.
117#[inline]
118pub(in crate::backend) fn try_decode_c_uint<Num: RetNumber>(
119 raw: RetReg<Num>,
120) -> io::Result<c::c_uint> {
121 if raw.is_in_range(-4095..0) {
122 // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
123 // in that range.
124 return Err(unsafe { Errno(raw.decode_error_code()) });
125 }
126
127 Ok(raw.decode_c_uint())
128}
129
130/// Check for an error from the result of a syscall which encodes a `usize` on
131/// success.
132#[inline]
133pub(in crate::backend) fn try_decode_usize<Num: RetNumber>(raw: RetReg<Num>) -> io::Result<usize> {
134 if raw.is_in_range(-4095..0) {
135 // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
136 // in that range.
137 return Err(unsafe { Errno(raw.decode_error_code()) });
138 }
139
140 Ok(raw.decode_usize())
141}
142
143/// Check for an error from the result of a syscall which encodes a
144/// `*mut c_void` on success.
145#[inline]
146pub(in crate::backend) fn try_decode_void_star<Num: RetNumber>(
147 raw: RetReg<Num>,
148) -> io::Result<*mut c::c_void> {
149 if raw.is_in_range(-4095..0) {
150 // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
151 // in that range.
152 return Err(unsafe { Errno(raw.decode_error_code()) });
153 }
154
155 Ok(raw.decode_void_star())
156}
157
158/// Check for an error from the result of a syscall which encodes a
159/// `u64` on success.
160#[cfg(target_pointer_width = "64")]
161#[inline]
162pub(in crate::backend) fn try_decode_u64<Num: RetNumber>(raw: RetReg<Num>) -> io::Result<u64> {
163 if raw.is_in_range(-4095..0) {
164 // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
165 // in that range.
166 return Err(unsafe { Errno(raw.decode_error_code()) });
167 }
168
169 Ok(raw.decode_u64())
170}
171
172/// Check for an error from the result of a syscall which encodes a file
173/// descriptor on success.
174///
175/// # Safety
176///
177/// This must only be used with syscalls which return file descriptors on
178/// success.
179#[inline]
180pub(in crate::backend) unsafe fn try_decode_raw_fd<Num: RetNumber>(
181 raw: RetReg<Num>,
182) -> io::Result<RawFd> {
183 // Instead of using `check_result` here, we just check for negative, since
184 // this function is only used for system calls which return file
185 // descriptors, and this produces smaller code.
186 if raw.is_negative() {
187 debug_assert!(raw.is_in_range(-4095..0));
188
189 // Tell the optimizer that we know the value is in the error range.
190 // This helps it avoid unnecessary integer conversions.
191 #[cfg(core_intrinsics)]
192 {
193 core::intrinsics::assume(raw.is_in_range(-4095..0));
194 }
195
196 return Err(Errno(raw.decode_error_code()));
197 }
198
199 Ok(raw.decode_raw_fd())
200}
201
202/// Check for an error from the result of a syscall which encodes no value on
203/// success. On success, return the unconsumed `raw` value.
204///
205/// # Safety
206///
207/// This must only be used with syscalls which return no value on success.
208#[inline]
209pub(in crate::backend) unsafe fn try_decode_void<Num: RetNumber>(
210 raw: RetReg<Num>,
211) -> io::Result<()> {
212 // Instead of using `check_result` here, we just check for zero, since this
213 // function is only used for system calls which have no other return value,
214 // and this produces smaller code.
215 if raw.is_nonzero() {
216 debug_assert!(raw.is_in_range(-4095..0));
217
218 // Tell the optimizer that we know the value is in the error range.
219 // This helps it avoid unnecessary integer conversions.
220 #[cfg(core_intrinsics)]
221 {
222 core::intrinsics::assume(raw.is_in_range(-4095..0));
223 }
224
225 return Err(Errno(raw.decode_error_code()));
226 }
227
228 raw.decode_void();
229
230 Ok(())
231}
232
233/// Check for an error from the result of a syscall which does not return on
234/// success. On success, return the unconsumed `raw` value.
235///
236/// # Safety
237///
238/// This must only be used with syscalls which do not return on success.
239#[cfg(any(feature = "event", feature = "runtime"))]
240#[inline]
241pub(in crate::backend) unsafe fn try_decode_error<Num: RetNumber>(raw: RetReg<Num>) -> io::Errno {
242 debug_assert!(raw.is_in_range(-4095..0));
243
244 // Tell the optimizer that we know the value is in the error range.
245 // This helps it avoid unnecessary integer conversions.
246 #[cfg(core_intrinsics)]
247 {
248 core::intrinsics::assume(raw.is_in_range(-4095..0));
249 }
250
251 Errno(raw.decode_error_code())
252}
253
254/// Return the contained `usize` value.
255#[cfg(not(debug_assertions))]
256#[inline]
257pub(in crate::backend) fn decode_usize_infallible<Num: RetNumber>(raw: RetReg<Num>) -> usize {
258 raw.decode_usize()
259}
260
261/// Return the contained `c_int` value.
262#[cfg(not(debug_assertions))]
263#[inline]
264pub(in crate::backend) fn decode_c_int_infallible<Num: RetNumber>(raw: RetReg<Num>) -> c::c_int {
265 raw.decode_c_int()
266}
267
268/// Return the contained `c_uint` value.
269#[cfg(not(debug_assertions))]
270#[inline]
271pub(in crate::backend) fn decode_c_uint_infallible<Num: RetNumber>(raw: RetReg<Num>) -> c::c_uint {
272 raw.decode_c_uint()
273}
274
275impl Errno {
276 /// `EACCES`
277 #[doc(alias = "ACCES")]
278 pub const ACCESS: Self = Self::from_errno(errno::EACCES);
279 /// `EADDRINUSE`
280 pub const ADDRINUSE: Self = Self::from_errno(errno::EADDRINUSE);
281 /// `EADDRNOTAVAIL`
282 pub const ADDRNOTAVAIL: Self = Self::from_errno(errno::EADDRNOTAVAIL);
283 /// `EADV`
284 pub const ADV: Self = Self::from_errno(errno::EADV);
285 /// `EAFNOSUPPORT`
286 pub const AFNOSUPPORT: Self = Self::from_errno(errno::EAFNOSUPPORT);
287 /// `EAGAIN`
288 pub const AGAIN: Self = Self::from_errno(errno::EAGAIN);
289 /// `EALREADY`
290 pub const ALREADY: Self = Self::from_errno(errno::EALREADY);
291 /// `EBADE`
292 pub const BADE: Self = Self::from_errno(errno::EBADE);
293 /// `EBADF`
294 pub const BADF: Self = Self::from_errno(errno::EBADF);
295 /// `EBADFD`
296 pub const BADFD: Self = Self::from_errno(errno::EBADFD);
297 /// `EBADMSG`
298 pub const BADMSG: Self = Self::from_errno(errno::EBADMSG);
299 /// `EBADR`
300 pub const BADR: Self = Self::from_errno(errno::EBADR);
301 /// `EBADRQC`
302 pub const BADRQC: Self = Self::from_errno(errno::EBADRQC);
303 /// `EBADSLT`
304 pub const BADSLT: Self = Self::from_errno(errno::EBADSLT);
305 /// `EBFONT`
306 pub const BFONT: Self = Self::from_errno(errno::EBFONT);
307 /// `EBUSY`
308 pub const BUSY: Self = Self::from_errno(errno::EBUSY);
309 /// `ECANCELED`
310 pub const CANCELED: Self = Self::from_errno(errno::ECANCELED);
311 /// `ECHILD`
312 pub const CHILD: Self = Self::from_errno(errno::ECHILD);
313 /// `ECHRNG`
314 pub const CHRNG: Self = Self::from_errno(errno::ECHRNG);
315 /// `ECOMM`
316 pub const COMM: Self = Self::from_errno(errno::ECOMM);
317 /// `ECONNABORTED`
318 pub const CONNABORTED: Self = Self::from_errno(errno::ECONNABORTED);
319 /// `ECONNREFUSED`
320 pub const CONNREFUSED: Self = Self::from_errno(errno::ECONNREFUSED);
321 /// `ECONNRESET`
322 pub const CONNRESET: Self = Self::from_errno(errno::ECONNRESET);
323 /// `EDEADLK`
324 pub const DEADLK: Self = Self::from_errno(errno::EDEADLK);
325 /// `EDEADLOCK`
326 pub const DEADLOCK: Self = Self::from_errno(errno::EDEADLOCK);
327 /// `EDESTADDRREQ`
328 pub const DESTADDRREQ: Self = Self::from_errno(errno::EDESTADDRREQ);
329 /// `EDOM`
330 pub const DOM: Self = Self::from_errno(errno::EDOM);
331 /// `EDOTDOT`
332 pub const DOTDOT: Self = Self::from_errno(errno::EDOTDOT);
333 /// `EDQUOT`
334 pub const DQUOT: Self = Self::from_errno(errno::EDQUOT);
335 /// `EEXIST`
336 pub const EXIST: Self = Self::from_errno(errno::EEXIST);
337 /// `EFAULT`
338 pub const FAULT: Self = Self::from_errno(errno::EFAULT);
339 /// `EFBIG`
340 pub const FBIG: Self = Self::from_errno(errno::EFBIG);
341 /// `EHOSTDOWN`
342 pub const HOSTDOWN: Self = Self::from_errno(errno::EHOSTDOWN);
343 /// `EHOSTUNREACH`
344 pub const HOSTUNREACH: Self = Self::from_errno(errno::EHOSTUNREACH);
345 /// `EHWPOISON`
346 pub const HWPOISON: Self = Self::from_errno(errno::EHWPOISON);
347 /// `EIDRM`
348 pub const IDRM: Self = Self::from_errno(errno::EIDRM);
349 /// `EILSEQ`
350 pub const ILSEQ: Self = Self::from_errno(errno::EILSEQ);
351 /// `EINPROGRESS`
352 pub const INPROGRESS: Self = Self::from_errno(errno::EINPROGRESS);
353 /// `EINTR`.
354 ///
355 /// For a convenient way to retry system calls that exit with `INTR`, use
356 /// [`retry_on_intr`].
357 ///
358 /// [`retry_on_intr`]: io::retry_on_intr
359 pub const INTR: Self = Self::from_errno(errno::EINTR);
360 /// `EINVAL`
361 pub const INVAL: Self = Self::from_errno(errno::EINVAL);
362 /// `EIO`
363 pub const IO: Self = Self::from_errno(errno::EIO);
364 /// `EISCONN`
365 pub const ISCONN: Self = Self::from_errno(errno::EISCONN);
366 /// `EISDIR`
367 pub const ISDIR: Self = Self::from_errno(errno::EISDIR);
368 /// `EISNAM`
369 pub const ISNAM: Self = Self::from_errno(errno::EISNAM);
370 /// `EKEYEXPIRED`
371 pub const KEYEXPIRED: Self = Self::from_errno(errno::EKEYEXPIRED);
372 /// `EKEYREJECTED`
373 pub const KEYREJECTED: Self = Self::from_errno(errno::EKEYREJECTED);
374 /// `EKEYREVOKED`
375 pub const KEYREVOKED: Self = Self::from_errno(errno::EKEYREVOKED);
376 /// `EL2HLT`
377 pub const L2HLT: Self = Self::from_errno(errno::EL2HLT);
378 /// `EL2NSYNC`
379 pub const L2NSYNC: Self = Self::from_errno(errno::EL2NSYNC);
380 /// `EL3HLT`
381 pub const L3HLT: Self = Self::from_errno(errno::EL3HLT);
382 /// `EL3RST`
383 pub const L3RST: Self = Self::from_errno(errno::EL3RST);
384 /// `ELIBACC`
385 pub const LIBACC: Self = Self::from_errno(errno::ELIBACC);
386 /// `ELIBBAD`
387 pub const LIBBAD: Self = Self::from_errno(errno::ELIBBAD);
388 /// `ELIBEXEC`
389 pub const LIBEXEC: Self = Self::from_errno(errno::ELIBEXEC);
390 /// `ELIBMAX`
391 pub const LIBMAX: Self = Self::from_errno(errno::ELIBMAX);
392 /// `ELIBSCN`
393 pub const LIBSCN: Self = Self::from_errno(errno::ELIBSCN);
394 /// `ELNRNG`
395 pub const LNRNG: Self = Self::from_errno(errno::ELNRNG);
396 /// `ELOOP`
397 pub const LOOP: Self = Self::from_errno(errno::ELOOP);
398 /// `EMEDIUMTYPE`
399 pub const MEDIUMTYPE: Self = Self::from_errno(errno::EMEDIUMTYPE);
400 /// `EMFILE`
401 pub const MFILE: Self = Self::from_errno(errno::EMFILE);
402 /// `EMLINK`
403 pub const MLINK: Self = Self::from_errno(errno::EMLINK);
404 /// `EMSGSIZE`
405 pub const MSGSIZE: Self = Self::from_errno(errno::EMSGSIZE);
406 /// `EMULTIHOP`
407 pub const MULTIHOP: Self = Self::from_errno(errno::EMULTIHOP);
408 /// `ENAMETOOLONG`
409 pub const NAMETOOLONG: Self = Self::from_errno(errno::ENAMETOOLONG);
410 /// `ENAVAIL`
411 pub const NAVAIL: Self = Self::from_errno(errno::ENAVAIL);
412 /// `ENETDOWN`
413 pub const NETDOWN: Self = Self::from_errno(errno::ENETDOWN);
414 /// `ENETRESET`
415 pub const NETRESET: Self = Self::from_errno(errno::ENETRESET);
416 /// `ENETUNREACH`
417 pub const NETUNREACH: Self = Self::from_errno(errno::ENETUNREACH);
418 /// `ENFILE`
419 pub const NFILE: Self = Self::from_errno(errno::ENFILE);
420 /// `ENOANO`
421 pub const NOANO: Self = Self::from_errno(errno::ENOANO);
422 /// `ENOBUFS`
423 pub const NOBUFS: Self = Self::from_errno(errno::ENOBUFS);
424 /// `ENOCSI`
425 pub const NOCSI: Self = Self::from_errno(errno::ENOCSI);
426 /// `ENODATA`
427 #[doc(alias = "NOATTR")]
428 pub const NODATA: Self = Self::from_errno(errno::ENODATA);
429 /// `ENODEV`
430 pub const NODEV: Self = Self::from_errno(errno::ENODEV);
431 /// `ENOENT`
432 pub const NOENT: Self = Self::from_errno(errno::ENOENT);
433 /// `ENOEXEC`
434 pub const NOEXEC: Self = Self::from_errno(errno::ENOEXEC);
435 /// `ENOKEY`
436 pub const NOKEY: Self = Self::from_errno(errno::ENOKEY);
437 /// `ENOLCK`
438 pub const NOLCK: Self = Self::from_errno(errno::ENOLCK);
439 /// `ENOLINK`
440 pub const NOLINK: Self = Self::from_errno(errno::ENOLINK);
441 /// `ENOMEDIUM`
442 pub const NOMEDIUM: Self = Self::from_errno(errno::ENOMEDIUM);
443 /// `ENOMEM`
444 pub const NOMEM: Self = Self::from_errno(errno::ENOMEM);
445 /// `ENOMSG`
446 pub const NOMSG: Self = Self::from_errno(errno::ENOMSG);
447 /// `ENONET`
448 pub const NONET: Self = Self::from_errno(errno::ENONET);
449 /// `ENOPKG`
450 pub const NOPKG: Self = Self::from_errno(errno::ENOPKG);
451 /// `ENOPROTOOPT`
452 pub const NOPROTOOPT: Self = Self::from_errno(errno::ENOPROTOOPT);
453 /// `ENOSPC`
454 pub const NOSPC: Self = Self::from_errno(errno::ENOSPC);
455 /// `ENOSR`
456 pub const NOSR: Self = Self::from_errno(errno::ENOSR);
457 /// `ENOSTR`
458 pub const NOSTR: Self = Self::from_errno(errno::ENOSTR);
459 /// `ENOSYS`
460 pub const NOSYS: Self = Self::from_errno(errno::ENOSYS);
461 /// `ENOTBLK`
462 pub const NOTBLK: Self = Self::from_errno(errno::ENOTBLK);
463 /// `ENOTCONN`
464 pub const NOTCONN: Self = Self::from_errno(errno::ENOTCONN);
465 /// `ENOTDIR`
466 pub const NOTDIR: Self = Self::from_errno(errno::ENOTDIR);
467 /// `ENOTEMPTY`
468 pub const NOTEMPTY: Self = Self::from_errno(errno::ENOTEMPTY);
469 /// `ENOTNAM`
470 pub const NOTNAM: Self = Self::from_errno(errno::ENOTNAM);
471 /// `ENOTRECOVERABLE`
472 pub const NOTRECOVERABLE: Self = Self::from_errno(errno::ENOTRECOVERABLE);
473 /// `ENOTSOCK`
474 pub const NOTSOCK: Self = Self::from_errno(errno::ENOTSOCK);
475 /// `ENOTSUP`
476 // On Linux, `ENOTSUP` has the same value as `EOPNOTSUPP`.
477 pub const NOTSUP: Self = Self::from_errno(errno::EOPNOTSUPP);
478 /// `ENOTTY`
479 pub const NOTTY: Self = Self::from_errno(errno::ENOTTY);
480 /// `ENOTUNIQ`
481 pub const NOTUNIQ: Self = Self::from_errno(errno::ENOTUNIQ);
482 /// `ENXIO`
483 pub const NXIO: Self = Self::from_errno(errno::ENXIO);
484 /// `EOPNOTSUPP`
485 pub const OPNOTSUPP: Self = Self::from_errno(errno::EOPNOTSUPP);
486 /// `EOVERFLOW`
487 pub const OVERFLOW: Self = Self::from_errno(errno::EOVERFLOW);
488 /// `EOWNERDEAD`
489 pub const OWNERDEAD: Self = Self::from_errno(errno::EOWNERDEAD);
490 /// `EPERM`
491 pub const PERM: Self = Self::from_errno(errno::EPERM);
492 /// `EPFNOSUPPORT`
493 pub const PFNOSUPPORT: Self = Self::from_errno(errno::EPFNOSUPPORT);
494 /// `EPIPE`
495 pub const PIPE: Self = Self::from_errno(errno::EPIPE);
496 /// `EPROTO`
497 pub const PROTO: Self = Self::from_errno(errno::EPROTO);
498 /// `EPROTONOSUPPORT`
499 pub const PROTONOSUPPORT: Self = Self::from_errno(errno::EPROTONOSUPPORT);
500 /// `EPROTOTYPE`
501 pub const PROTOTYPE: Self = Self::from_errno(errno::EPROTOTYPE);
502 /// `ERANGE`
503 pub const RANGE: Self = Self::from_errno(errno::ERANGE);
504 /// `EREMCHG`
505 pub const REMCHG: Self = Self::from_errno(errno::EREMCHG);
506 /// `EREMOTE`
507 pub const REMOTE: Self = Self::from_errno(errno::EREMOTE);
508 /// `EREMOTEIO`
509 pub const REMOTEIO: Self = Self::from_errno(errno::EREMOTEIO);
510 /// `ERESTART`
511 pub const RESTART: Self = Self::from_errno(errno::ERESTART);
512 /// `ERFKILL`
513 pub const RFKILL: Self = Self::from_errno(errno::ERFKILL);
514 /// `EROFS`
515 pub const ROFS: Self = Self::from_errno(errno::EROFS);
516 /// `ESHUTDOWN`
517 pub const SHUTDOWN: Self = Self::from_errno(errno::ESHUTDOWN);
518 /// `ESOCKTNOSUPPORT`
519 pub const SOCKTNOSUPPORT: Self = Self::from_errno(errno::ESOCKTNOSUPPORT);
520 /// `ESPIPE`
521 pub const SPIPE: Self = Self::from_errno(errno::ESPIPE);
522 /// `ESRCH`
523 pub const SRCH: Self = Self::from_errno(errno::ESRCH);
524 /// `ESRMNT`
525 pub const SRMNT: Self = Self::from_errno(errno::ESRMNT);
526 /// `ESTALE`
527 pub const STALE: Self = Self::from_errno(errno::ESTALE);
528 /// `ESTRPIPE`
529 pub const STRPIPE: Self = Self::from_errno(errno::ESTRPIPE);
530 /// `ETIME`
531 pub const TIME: Self = Self::from_errno(errno::ETIME);
532 /// `ETIMEDOUT`
533 pub const TIMEDOUT: Self = Self::from_errno(errno::ETIMEDOUT);
534 /// `E2BIG`
535 #[doc(alias = "2BIG")]
536 pub const TOOBIG: Self = Self::from_errno(errno::E2BIG);
537 /// `ETOOMANYREFS`
538 pub const TOOMANYREFS: Self = Self::from_errno(errno::ETOOMANYREFS);
539 /// `ETXTBSY`
540 pub const TXTBSY: Self = Self::from_errno(errno::ETXTBSY);
541 /// `EUCLEAN`
542 pub const UCLEAN: Self = Self::from_errno(errno::EUCLEAN);
543 /// `EUNATCH`
544 pub const UNATCH: Self = Self::from_errno(errno::EUNATCH);
545 /// `EUSERS`
546 pub const USERS: Self = Self::from_errno(errno::EUSERS);
547 /// `EWOULDBLOCK`
548 pub const WOULDBLOCK: Self = Self::from_errno(errno::EWOULDBLOCK);
549 /// `EXDEV`
550 pub const XDEV: Self = Self::from_errno(errno::EXDEV);
551 /// `EXFULL`
552 pub const XFULL: Self = Self::from_errno(errno::EXFULL);
553}
554