/rust/registry/src/index.crates.io-1949cf8c6b5b557f/mio-1.1.0/src/sys/mod.rs

Source
//! Module with system specific types.
//!
//! Required types:
//!
//! * `Event`: a type alias for the system specific event, e.g. `kevent` or
//!   `epoll_event`.
//! * `event`: a module with various helper functions for `Event`, see
//!   [`crate::event::Event`] for the required functions.
//! * `Events`: collection of `Event`s, see [`crate::Events`].
//! * `IoSourceState`: state for the `IoSource` type.
//! * `Selector`: selector used to register event sources and poll for events,
//!   see [`crate::Poll`] and [`crate::Registry`] for required methods.
//! * `tcp` and `udp` modules: see the [`crate::net`] module.
//! * `Waker`: see [`crate::Waker`].

cfg_os_poll! {
    macro_rules! debug_detail {
        (
            $type: ident ($event_type: ty), $test: path,
            $($(#[$target: meta])* $libc: ident :: $flag: ident),+ $(,)*
        ) => {
            struct $type($event_type);

            impl fmt::Debug for $type {
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    let mut written_one = false;
                    $(
                        $(#[$target])*
                        #[allow(clippy::bad_bit_mask)] // Apparently some flags are zero.
                        {
                            // Windows doesn't use `libc` but the `afd` module.
                            if $test(&self.0, &$libc :: $flag) {
                                if !written_one {
                                    write!(f, "{}", stringify!($flag))?;
                                    written_one = true;
                                } else {
                                    write!(f, "|{}", stringify!($flag))?;
                                }
                            }
                        }
                    )+
                    if !written_one {
                        write!(f, "(empty)")
                    } else {
                        Ok(())
                    }
                }
            }
        };
    }
}

#[cfg(any(unix, target_os = "hermit"))]
cfg_os_poll! {
    mod unix;
    #[allow(unused_imports)]
    pub use self::unix::*;
}

#[cfg(windows)]
cfg_os_poll! {
    mod windows;
    pub use self::windows::*;
}

#[cfg(target_os = "wasi")]
cfg_os_poll! {
    mod wasi;
    pub(crate) use self::wasi::*;
}

cfg_not_os_poll! {
    mod shell;
    pub(crate) use self::shell::*;

    #[cfg(unix)]
    cfg_any_os_ext! {
        mod unix;
        #[cfg(feature = "os-ext")]
        pub use self::unix::SourceFd;
    }
}

/// Define the `listen` backlog parameters as in the standard library. This
/// helps avoid hardcoded unsynchronized values and allows better control of
/// default values depending on the target.
///
/// Selecting a “valid” default value can be tricky due to:
///
/// - It often serves only as a hint and may be rounded, trimmed, or ignored by
///   the OS.
///
/// - It is sometimes provided as a "magic" value, for example, -1. This
///   value is undocumented and not standard, but it is often used to represent
///   the largest possible backlog size. This happens due to signed/unsigned
///   conversion and rounding to the upper bound performed by the OS.
///
/// - Default values vary depending on the OS and its version. Common defaults
///   include: -1, 128, 1024, and 4096.
///
// Here is the original code from the standard library
// https://github.com/rust-lang/rust/blob/4f808ba6bf9f1c8dde30d009e73386d984491587/library/std/src/os/unix/net/listener.rs#L72
//
#[allow(dead_code)]
#[cfg(any(
    target_os = "windows",
    target_os = "redox",
    target_os = "espidf",
    target_os = "horizon"
))]
pub(crate) const LISTEN_BACKLOG_SIZE: i32 = 128;

/// This is a special case for some target(s) supported by `mio`.  This value
/// is needed because `libc::SOMAXCON` (used as a fallback for unknown targets)
/// is not implemented for them. Feel free to update this if the `libc` crate
/// changes.
#[allow(dead_code)]
#[cfg(target_os = "hermit")]
pub(crate) const LISTEN_BACKLOG_SIZE: i32 = 1024;

#[allow(dead_code)]
#[cfg(any(
    // Silently capped to `/proc/sys/net/core/somaxconn`.
    target_os = "linux",
    // Silently capped to `kern.ipc.soacceptqueue`.
    target_os = "freebsd",
    // Silently capped to `kern.somaxconn sysctl`.
    target_os = "openbsd",
    // Silently capped to the default 128.
    target_vendor = "apple",
))]
pub(crate) const LISTEN_BACKLOG_SIZE: i32 = -1;

#[allow(dead_code)]
#[cfg(not(any(
    target_os = "windows",
    target_os = "redox",
    target_os = "espidf",
    target_os = "horizon",
    target_os = "linux",
    target_os = "freebsd",
    target_os = "openbsd",
    target_os = "wasi",
    target_os = "hermit",
    target_vendor = "apple",
)))]
pub(crate) const LISTEN_BACKLOG_SIZE: i32 = libc::SOMAXCONN;

Coverage Report

Created: 2025-10-28 06:41

Line	Count	Source
1		//! Module with system specific types.
2		//!
3		//! Required types:
4		//!
5		//! * `Event`: a type alias for the system specific event, e.g. `kevent` or
6		//! `epoll_event`.
7		//! * `event`: a module with various helper functions for `Event`, see
8		//! [`crate::event::Event`] for the required functions.
9		//! * `Events`: collection of `Event`s, see [`crate::Events`].
10		//! * `IoSourceState`: state for the `IoSource` type.
11		//! * `Selector`: selector used to register event sources and poll for events,
12		//! see [`crate::Poll`] and [`crate::Registry`] for required methods.
13		//! * `tcp` and `udp` modules: see the [`crate::net`] module.
14		//! * `Waker`: see [`crate::Waker`].
15
16		cfg_os_poll! {
17		macro_rules! debug_detail {
18		(
19		$type: ident ($event_type: ty), $test: path,
20		$($(#[$target: meta])* $libc: ident :: $flag: ident),+ $(,)*
21		) => {
22		struct $type($event_type);
23
24		impl fmt::Debug for $type {
25	0	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
26	0	let mut written_one = false;
27		$(
28		$(#[$target])*
29		#[allow(clippy::bad_bit_mask)] // Apparently some flags are zero.
30		{
31		// Windows doesn't use `libc` but the `afd` module.
32	0	if $test(&self.0, &$libc :: $flag) {
33	0	if !written_one {
34	0	write!(f, "{}", stringify!($flag))?;
35	0	written_one = true;
36		} else {
37	0	write!(f, "\|{}", stringify!($flag))?;
38		}
39	0	}
40		}
41		)+
42	0	if !written_one {
43	0	write!(f, "(empty)")
44		} else {
45	0	Ok(())
46		}
47	0	}
48		}
49		};
50		}
51		}
52
53		#[cfg(any(unix, target_os = "hermit"))]
54		cfg_os_poll! {
55		mod unix;
56		#[allow(unused_imports)]
57		pub use self::unix::*;
58		}
59
60		#[cfg(windows)]
61		cfg_os_poll! {
62		mod windows;
63		pub use self::windows::*;
64		}
65
66		#[cfg(target_os = "wasi")]
67		cfg_os_poll! {
68		mod wasi;
69		pub(crate) use self::wasi::*;
70		}
71
72		cfg_not_os_poll! {
73		mod shell;
74		pub(crate) use self::shell::*;
75
76		#[cfg(unix)]
77		cfg_any_os_ext! {
78		mod unix;
79		#[cfg(feature = "os-ext")]
80		pub use self::unix::SourceFd;
81		}
82		}
83
84		/// Define the `listen` backlog parameters as in the standard library. This
85		/// helps avoid hardcoded unsynchronized values and allows better control of
86		/// default values depending on the target.
87		///
88		/// Selecting a “valid” default value can be tricky due to:
89		///
90		/// - It often serves only as a hint and may be rounded, trimmed, or ignored by
91		/// the OS.
92		///
93		/// - It is sometimes provided as a "magic" value, for example, -1. This
94		/// value is undocumented and not standard, but it is often used to represent
95		/// the largest possible backlog size. This happens due to signed/unsigned
96		/// conversion and rounding to the upper bound performed by the OS.
97		///
98		/// - Default values vary depending on the OS and its version. Common defaults
99		/// include: -1, 128, 1024, and 4096.
100		///
101		// Here is the original code from the standard library
102		// https://github.com/rust-lang/rust/blob/4f808ba6bf9f1c8dde30d009e73386d984491587/library/std/src/os/unix/net/listener.rs#L72
103		//
104		#[allow(dead_code)]
105		#[cfg(any(
106		target_os = "windows",
107		target_os = "redox",
108		target_os = "espidf",
109		target_os = "horizon"
110		))]
111		pub(crate) const LISTEN_BACKLOG_SIZE: i32 = 128;
112
113		/// This is a special case for some target(s) supported by `mio`. This value
114		/// is needed because `libc::SOMAXCON` (used as a fallback for unknown targets)
115		/// is not implemented for them. Feel free to update this if the `libc` crate
116		/// changes.
117		#[allow(dead_code)]
118		#[cfg(target_os = "hermit")]
119		pub(crate) const LISTEN_BACKLOG_SIZE: i32 = 1024;
120
121		#[allow(dead_code)]
122		#[cfg(any(
123		// Silently capped to `/proc/sys/net/core/somaxconn`.
124		target_os = "linux",
125		// Silently capped to `kern.ipc.soacceptqueue`.
126		target_os = "freebsd",
127		// Silently capped to `kern.somaxconn sysctl`.
128		target_os = "openbsd",
129		// Silently capped to the default 128.
130		target_vendor = "apple",
131		))]
132		pub(crate) const LISTEN_BACKLOG_SIZE: i32 = -1;
133
134		#[allow(dead_code)]
135		#[cfg(not(any(
136		target_os = "windows",
137		target_os = "redox",
138		target_os = "espidf",
139		target_os = "horizon",
140		target_os = "linux",
141		target_os = "freebsd",
142		target_os = "openbsd",
143		target_os = "wasi",
144		target_os = "hermit",
145		target_vendor = "apple",
146		)))]
147		pub(crate) const LISTEN_BACKLOG_SIZE: i32 = libc::SOMAXCONN;