// SPDX-License-Identifier: GPL-2.0 //! Memory orderings.//!//! The semantics of these orderings follows the [`LKMM`] definitions and rules.//!//! - [`Acquire`] provides ordering between the load part of the annotated operation and all the//!   following memory accesses, and if there is a store part, the store part has the [`Relaxed`]//!   ordering.//! - [`Release`] provides ordering between all the preceding memory accesses and the store part of//!   the annotated operation, and if there is a load part, the load part has the [`Relaxed`]//!   ordering.//! - [`Full`] means "fully-ordered", that is://!   - It provides ordering between all the preceding memory accesses and the annotated operation.//!   - It provides ordering between the annotated operation and all the following memory accesses.//!   - It provides ordering between all the preceding memory accesses and all the following memory//!     accesses.//!   - All the orderings are the same strength as a full memory barrier (i.e. `smp_mb(Full)`).//! - [`Relaxed`] provides no ordering except the dependency orderings. Dependency orderings are//!   described in "DEPENDENCY RELATIONS" in [`LKMM`]'s [`explanation`].//!//! [`LKMM`]: srctree/tools/memory-model///! [`explanation`]: srctree/tools/memory-model/Documentation/explanation.txt /// The annotation type for relaxed memory ordering, for the description of relaxed memory/// ordering, see [module-level documentation].////// [module-level documentation]: crate::sync::atomic::orderingpub struct Relaxed; /// The annotation type for acquire memory ordering, for the description of acquire memory/// ordering, see [module-level documentation].////// [module-level documentation]: crate::sync::atomic::orderingpub struct Acquire; /// The annotation type for release memory ordering, for the description of release memory/// ordering, see [module-level documentation].////// [module-level documentation]: crate::sync::atomic::orderingpub struct Release; /// The annotation type for fully-ordered memory ordering, for the description fully-ordered memory/// ordering, see [module-level documentation].////// [module-level documentation]: crate::sync::atomic::orderingpub struct Full; /// Describes the exact memory ordering.#[doc(hidden)]pub enum OrderingType {    /// Relaxed ordering.    Relaxed,    /// Acquire ordering.    Acquire,    /// Release ordering.    Release,    /// Fully-ordered.    Full,} mod internal {    /// Sealed trait, can be only implemented inside atomic mod.    pub trait Sealed {}     impl Sealed for super::Relaxed {}    impl Sealed for super::Acquire {}    impl Sealed for super::Release {}    impl Sealed for super::Full {}} /// The trait bound for annotating operations that support any ordering.pub trait Ordering: internal::Sealed {    /// Describes the exact memory ordering.    const TYPE: OrderingType;} impl Ordering for Relaxed {    const TYPE: OrderingType = OrderingType::Relaxed;} impl Ordering for Acquire {    const TYPE: OrderingType = OrderingType::Acquire;} impl Ordering for Release {    const TYPE: OrderingType = OrderingType::Release;} impl Ordering for Full {    const TYPE: OrderingType = OrderingType::Full;} /// The trait bound for operations that only support acquire or relaxed ordering.pub trait AcquireOrRelaxed: Ordering {} impl AcquireOrRelaxed for Acquire {}impl AcquireOrRelaxed for Relaxed {} /// The trait bound for operations that only support release or relaxed ordering.pub trait ReleaseOrRelaxed: Ordering {} impl ReleaseOrRelaxed for Release {}impl ReleaseOrRelaxed for Relaxed {}