7143379a52
RustHermit publishs a new kernel interface and supports a common BSD socket layer. By supporting this interface, the implementation can be harmonized to other operating systems. To realize this socket layer, the handling of file descriptors is also harmonized to other operating systems.
93 lines
2.7 KiB
Rust
93 lines
2.7 KiB
Rust
//! Platform-independent platform abstraction
|
|
//!
|
|
//! This is the platform-independent portion of the standard library's
|
|
//! platform abstraction layer, whereas `std::sys` is the
|
|
//! platform-specific portion.
|
|
//!
|
|
//! The relationship between `std::sys_common`, `std::sys` and the
|
|
//! rest of `std` is complex, with dependencies going in all
|
|
//! directions: `std` depending on `sys_common`, `sys_common`
|
|
//! depending on `sys`, and `sys` depending on `sys_common` and `std`.
|
|
//! This is because `sys_common` not only contains platform-independent code,
|
|
//! but also code that is shared between the different platforms in `sys`.
|
|
//! Ideally all that shared code should be moved to `sys::common`,
|
|
//! and the dependencies between `std`, `sys_common` and `sys` all would form a dag.
|
|
//! Progress on this is tracked in #84187.
|
|
|
|
#![allow(missing_docs)]
|
|
#![allow(missing_debug_implementations)]
|
|
|
|
#[cfg(test)]
|
|
mod tests;
|
|
|
|
pub mod backtrace;
|
|
pub mod fs;
|
|
pub mod io;
|
|
pub mod lazy_box;
|
|
pub mod memchr;
|
|
pub mod once;
|
|
pub mod process;
|
|
pub mod thread;
|
|
pub mod thread_info;
|
|
pub mod thread_local_dtor;
|
|
pub mod thread_parking;
|
|
pub mod wstr;
|
|
pub mod wtf8;
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(target_os = "windows")] {
|
|
pub use crate::sys::thread_local_key;
|
|
} else {
|
|
pub mod thread_local_key;
|
|
}
|
|
}
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(any(target_os = "l4re",
|
|
feature = "restricted-std",
|
|
all(target_family = "wasm", not(target_os = "emscripten")),
|
|
all(target_vendor = "fortanix", target_env = "sgx")))] {
|
|
pub use crate::sys::net;
|
|
} else {
|
|
pub mod net;
|
|
}
|
|
}
|
|
|
|
// common error constructors
|
|
|
|
/// A trait for viewing representations from std types
|
|
#[doc(hidden)]
|
|
pub trait AsInner<Inner: ?Sized> {
|
|
fn as_inner(&self) -> &Inner;
|
|
}
|
|
|
|
/// A trait for viewing representations from std types
|
|
#[doc(hidden)]
|
|
pub trait AsInnerMut<Inner: ?Sized> {
|
|
fn as_inner_mut(&mut self) -> &mut Inner;
|
|
}
|
|
|
|
/// A trait for extracting representations from std types
|
|
#[doc(hidden)]
|
|
pub trait IntoInner<Inner> {
|
|
fn into_inner(self) -> Inner;
|
|
}
|
|
|
|
/// A trait for creating std types from internal representations
|
|
#[doc(hidden)]
|
|
pub trait FromInner<Inner> {
|
|
fn from_inner(inner: Inner) -> Self;
|
|
}
|
|
|
|
// Computes (value*numer)/denom without overflow, as long as both
|
|
// (numer*denom) and the overall result fit into i64 (which is the case
|
|
// for our time conversions).
|
|
#[allow(dead_code)] // not used on all platforms
|
|
pub fn mul_div_u64(value: u64, numer: u64, denom: u64) -> u64 {
|
|
let q = value / denom;
|
|
let r = value % denom;
|
|
// Decompose value as (value/denom*denom + value%denom),
|
|
// substitute into (value*numer)/denom and simplify.
|
|
// r < denom, so (denom*numer) is the upper bound of (r*numer)
|
|
q * numer + r * numer / denom
|
|
}
|