lib: use `HartMask` struct from `sbi-spec` crate

Signed-off-by: Zhouqi Jiang <luojia@hust.edu.cn>

Cargo.toml

@@ -17,7 +17,7 @@ edition = "2021"
 exclude = ["/.github"]
 
 [dependencies]
-sbi-spec = "0.0.7-alpha.2"
+sbi-spec = "0.0.7-alpha.3"
 riscv = { version = "0.10.1", optional = true }
 rustsbi-macros = { version = "0.4.0-alpha.1", path = "macros" }
 static_assertions = "1.1.0"

examples/derive/commons.rs

@@ -1,8 +1,8 @@
 // Mock implementaion module. Actual SBI implementaion should implement
 // those SBI extensions with machine environment specific hardware features.
 
-use rustsbi::{EnvInfo, HartMask};
-use sbi_spec::binary::SbiRet;
+use rustsbi::EnvInfo;
+use sbi_spec::binary::{HartMask, SbiRet};
 
 pub struct MyFence;
 

src/hart_mask.rs

@@ -1,88 +0,0 @@
-/// Hart mask structure in SBI function calls.
-#[derive(Debug, Copy, Clone)]
-pub struct HartMask {
-    inner: BitVector,
-}
-
-impl HartMask {
-    /// Construct a hart mask from mask value and base hart id.
-    #[inline]
-    pub const fn from_mask_base(hart_mask: usize, hart_mask_base: usize) -> HartMask {
-        HartMask {
-            inner: BitVector {
-                hart_mask,
-                hart_mask_base,
-            },
-        }
-    }
-
-    /// Returns `hart_mask` and `hart_mask_base` parameters from the hart mask structure.
-    #[inline]
-    pub const fn into_inner(self) -> (usize, usize) {
-        (self.inner.hart_mask, self.inner.hart_mask_base)
-    }
-
-    /// Check if the `hart_id` is included in this hart mask structure.
-    #[inline]
-    pub const fn has_bit(&self, hart_id: usize) -> bool {
-        let BitVector {
-            hart_mask,
-            hart_mask_base,
-        } = self.inner;
-        if hart_mask_base == usize::MAX {
-            // If `hart_mask_base` equals `usize::MAX`, that means `hart_mask` is ignored
-            // and all available harts must be considered.
-            return true;
-        }
-        let Some(idx) = hart_id.checked_sub(hart_mask_base) else {
-            // hart_id < hart_mask_base, not in current mask range
-            return false;
-        };
-        if idx >= usize::BITS as usize {
-            // hart_idx >= hart_mask_base + XLEN, not in current mask range
-            return false;
-        }
-        hart_mask & (1 << idx) != 0
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-struct BitVector {
-    hart_mask: usize,
-    hart_mask_base: usize,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::HartMask;
-
-    #[test]
-    fn rustsbi_hart_mask() {
-        let mask = HartMask::from_mask_base(0b1, 400);
-        assert!(!mask.has_bit(0));
-        assert!(mask.has_bit(400));
-        assert!(!mask.has_bit(401));
-        let mask = HartMask::from_mask_base(0b110, 500);
-        assert!(!mask.has_bit(0));
-        assert!(!mask.has_bit(500));
-        assert!(mask.has_bit(501));
-        assert!(mask.has_bit(502));
-        assert!(!mask.has_bit(500 + (usize::BITS as usize)));
-        let max_bit = 1 << (usize::BITS - 1);
-        let mask = HartMask::from_mask_base(max_bit, 600);
-        assert!(mask.has_bit(600 + (usize::BITS as usize) - 1));
-        assert!(!mask.has_bit(600 + (usize::BITS as usize)));
-        let mask = HartMask::from_mask_base(0b11, usize::MAX - 1);
-        assert!(!mask.has_bit(usize::MAX - 2));
-        assert!(mask.has_bit(usize::MAX - 1));
-        assert!(mask.has_bit(usize::MAX));
-        assert!(!mask.has_bit(0));
-        // hart_mask_base == usize::MAX is special, it means hart_mask should be ignored
-        // and this hart mask contains all harts available
-        let mask = HartMask::from_mask_base(0, usize::MAX);
-        for i in 0..5 {
-            assert!(mask.has_bit(i));
-        }
-        assert!(mask.has_bit(usize::MAX));
-    }
-}

src/ipi.rs

@@ -1,5 +1,4 @@
-use crate::hart_mask::HartMask;
-use sbi_spec::binary::SbiRet;
+use sbi_spec::binary::{HartMask, SbiRet};
 
 /// Inter-processor interrupt support.
 pub trait Ipi {

src/lib.rs

@@ -205,7 +205,7 @@
 //!
 //! ```no_run
 //! # use rustsbi::RustSBI;
-//! # use sbi_spec::binary::SbiRet;
+//! # use sbi_spec::binary::{SbiRet, HartMask};
 //! # struct MyEnvInfo;
 //! # impl rustsbi::EnvInfo for MyEnvInfo {
 //! #     fn mvendorid(&self) -> usize { 1 }
@@ -431,7 +431,7 @@
 //! and function IDs can be checked before calling RustSBI `env.handle_ecall`.
 //!
 //! ```no_run
-//! # use sbi_spec::binary::SbiRet;
+//! # use sbi_spec::binary::{SbiRet, HartMask};
 //! # struct MyExtensionSBI {}
 //! # impl MyExtensionSBI { fn handle_ecall(&self, params: ()) -> SbiRet { SbiRet::success(0) } }
 //! # struct MySBI {} // Mock, prevent doc test error when feature singleton is enabled
@@ -542,9 +542,7 @@
 
 mod console;
 mod cppc;
-mod hart_mask;
 mod hsm;
-// mod instance;
 mod ipi;
 mod nacl;
 mod pmu;
@@ -598,8 +596,8 @@ pub extern crate sbi_spec as spec;
 ///
 /// struct MyFence { /* fields */ }
 ///
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+/// #
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// impl rustsbi::Fence for MyFence {
 ///     /* implementation details */
 /// #   fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -634,8 +632,8 @@ pub extern crate sbi_spec as spec;
 ///     timer: MyTimer,
 /// #   #[cfg(feature = "machine")] info: () // compile would success on #[cfg(feature = "machine")], cause it always to fail
 /// }
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+///
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -682,6 +680,7 @@ pub extern crate sbi_spec as spec;
 /// name `info`. We can do it like:
 ///
 /// ```rust
+/// # use rustsbi::RustSBI;
 /// #[derive(RustSBI)]
 /// struct MySBI {
 ///     fence: MyFence,
@@ -700,8 +699,7 @@ pub extern crate sbi_spec as spec;
 ///     #[inline]
 ///     fn mimpid(&self) -> usize { todo!("add real value here") }
 /// }
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -813,6 +811,7 @@ pub extern crate sbi_spec as spec;
 /// For example:
 ///
 /// ```rust
+/// # use rustsbi::RustSBI;
 /// #[derive(RustSBI)]
 /// struct MySBI {
 ///     fence: MyFence,
@@ -821,8 +820,7 @@ pub extern crate sbi_spec as spec;
 ///
 /// // Here, we assume that `MyFence` implements `rustsbi::Fence`
 /// // and `MyEnvInfo` implements `rustsbi::EnvInfo`.
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -847,8 +845,8 @@ pub extern crate sbi_spec as spec;
 ///     rfnc: MyFence, // <-- Second field providing `rustsbi::Fence` implementation
 ///     info: MyEnvInfo,
 /// }
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+///
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -867,6 +865,7 @@ pub extern crate sbi_spec as spec;
 /// constant generics and where clauses.
 ///
 /// ```rust
+/// # use rustsbi::RustSBI;
 /// #[derive(RustSBI)]
 /// struct MySBI<'a, T: rustsbi::Fence, U, const N: usize>
 /// where
@@ -878,8 +877,7 @@ pub extern crate sbi_spec as spec;
 ///     _dummy: [u8; N],
 /// }
 ///
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -911,8 +909,8 @@ pub extern crate sbi_spec as spec;
 /// // Notably, a `#[warn(unused)]` would be raised if `fence` is not furtherly used
 /// // by following code; `console` and `info` fields are not warned because they are
 /// // internally used by the trait implementation derived in the RustSBI macro.
-/// # use rustsbi::{HartMask, RustSBI};
-/// # use sbi_spec::binary::{SbiRet, Physical};
+/// # use rustsbi::RustSBI;
+/// # use sbi_spec::binary::{SbiRet, Physical, HartMask};
 /// # struct MyConsole;
 /// # impl rustsbi::Console for MyConsole {
 /// #     fn write(&self, _: Physical<&[u8]>) -> SbiRet { unimplemented!() }
@@ -949,8 +947,8 @@ pub extern crate sbi_spec as spec;
 ///
 /// // RustSBI will now use the `some_other_name` field implementing `rustsbi::Fence`
 /// // as the implementation of SBI Remote Fence extension.
-/// # use rustsbi::{HartMask, RustSBI};
-/// # use sbi_spec::binary::{SbiRet, Physical};
+/// # use rustsbi::RustSBI;
+/// # use sbi_spec::binary::{SbiRet, Physical, HartMask};
 /// # struct MyConsole;
 /// # impl rustsbi::Console for MyConsole {
 /// #     fn write(&self, _: Physical<&[u8]>) -> SbiRet { unimplemented!() }
@@ -980,8 +978,8 @@ pub extern crate sbi_spec as spec;
 ///
 /// // Both Ipi and Timer extension implementations are now provided by the
 /// // `clint` field implementing both `rustsbi::Ipi` and `rustsbi::Timer`.
-/// # use rustsbi::{HartMask, RustSBI};
-/// # use sbi_spec::binary::{SbiRet, Physical};
+/// # use rustsbi::RustSBI;
+/// # use sbi_spec::binary::{SbiRet, Physical, HartMask};
 /// # struct Clint;
 /// # impl rustsbi::Timer for Clint {
 /// #     fn set_timer(&self, stime_value: u64) { unimplemented!() }
@@ -1001,14 +999,14 @@ pub extern crate sbi_spec as spec;
 /// Alternatively, the RustSBI derive macro also accepts tuple structs or unit structs.
 ///
 /// ```rust
+/// # use rustsbi::RustSBI;
 /// // Tuple structs.
 /// // No field names are provided; the structure must provide helper attributes
 /// // to identify the extensions for the RustSBI derive macro.
 /// #[derive(RustSBI)]
 /// struct MySBI(#[rustsbi(fence)] MyFence, #[rustsbi(info)] MyEnvInfo);
 ///
-/// # use rustsbi::{RustSBI, HartMask};
-/// # use sbi_spec::binary::SbiRet;
+/// # use sbi_spec::binary::{SbiRet, HartMask};
 /// # struct MyFence;
 /// # impl rustsbi::Fence for MyFence {
 /// #     fn remote_fence_i(&self, _: HartMask) -> SbiRet { unimplemented!() }
@@ -1040,7 +1038,6 @@ pub use rustsbi_macros::RustSBI;
 
 pub use console::Console;
 pub use cppc::Cppc;
-pub use hart_mask::HartMask;
 pub use hsm::Hsm;
 pub use ipi::Ipi;
 pub use nacl::Nacl;

src/rfence.rs

@@ -1,5 +1,4 @@
-use crate::hart_mask::HartMask;
-use sbi_spec::binary::SbiRet;
+use sbi_spec::binary::{HartMask, SbiRet};
 
 /// Remote Fence support extension.
 ///

src/traits.rs

@@ -1,7 +1,6 @@
-use crate::HartMask;
 #[cfg(feature = "machine")]
 use riscv::register::{marchid, mimpid, mvendorid};
-use spec::binary::{Physical, SbiRet, SharedPtr};
+use spec::binary::{HartMask, Physical, SbiRet, SharedPtr};
 
 /// RustSBI environment call handler.
 pub trait RustSBI {

tests/build-full.rs

@@ -1,6 +1,6 @@
 use rustsbi::RustSBI;
 use sbi_spec::{
-    binary::{Physical, SbiRet, SharedPtr},
+    binary::{HartMask, Physical, SbiRet, SharedPtr},
     nacl::shmem_size::NATIVE,
 };
 
@@ -190,7 +190,7 @@ impl rustsbi::Hsm for DummyHsm {
 struct DummyIpi;
 
 impl rustsbi::Ipi for DummyIpi {
-    fn send_ipi(&self, _: rustsbi::HartMask) -> SbiRet {
+    fn send_ipi(&self, _: HartMask) -> SbiRet {
         unimplemented!()
     }
 }
@@ -257,15 +257,15 @@ impl rustsbi::Reset for DummyReset {
 struct DummyFence;
 
 impl rustsbi::Fence for DummyFence {
-    fn remote_fence_i(&self, _: rustsbi::HartMask) -> SbiRet {
+    fn remote_fence_i(&self, _: HartMask) -> SbiRet {
         unimplemented!()
     }
 
-    fn remote_sfence_vma(&self, _: rustsbi::HartMask, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma(&self, _: HartMask, _: usize, _: usize) -> SbiRet {
         unimplemented!()
     }
 
-    fn remote_sfence_vma_asid(&self, _: rustsbi::HartMask, _: usize, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma_asid(&self, _: HartMask, _: usize, _: usize, _: usize) -> SbiRet {
         unimplemented!()
     }
 }

tests/build-rename.rs

@@ -1,13 +1,12 @@
-use std::cell::RefCell;
-
-use rustsbi::{HartMask, RustSBI};
+use rustsbi::RustSBI;
 use sbi_spec::{
-    binary::{Physical, SbiRet},
+    binary::{HartMask, Physical, SbiRet},
     dbcn::EID_DBCN,
     rfnc::EID_RFNC,
     spi::EID_SPI,
     time::EID_TIME,
 };
+use std::cell::RefCell;
 
 #[derive(RustSBI)]
 struct AssignOne {
@@ -92,15 +91,15 @@ impl rustsbi::Console for DummyConsole {
 struct DummyFence;
 
 impl rustsbi::Fence for DummyFence {
-    fn remote_fence_i(&self, _: rustsbi::HartMask) -> SbiRet {
+    fn remote_fence_i(&self, _: HartMask) -> SbiRet {
         SbiRet::success(4)
     }
 
-    fn remote_sfence_vma(&self, _: rustsbi::HartMask, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma(&self, _: HartMask, _: usize, _: usize) -> SbiRet {
         SbiRet::success(5)
     }
 
-    fn remote_sfence_vma_asid(&self, _: rustsbi::HartMask, _: usize, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma_asid(&self, _: HartMask, _: usize, _: usize, _: usize) -> SbiRet {
         SbiRet::success(6)
     }
 }

tests/build-skip.rs

@@ -1,6 +1,6 @@
 use rustsbi::RustSBI;
 use sbi_spec::{
-    binary::{Physical, SbiRet},
+    binary::{HartMask, Physical, SbiRet},
     dbcn::EID_DBCN,
     rfnc::EID_RFNC,
 };
@@ -109,15 +109,15 @@ impl rustsbi::Console for DummyConsole {
 struct DummyFence;
 
 impl rustsbi::Fence for DummyFence {
-    fn remote_fence_i(&self, _: rustsbi::HartMask) -> SbiRet {
+    fn remote_fence_i(&self, _: HartMask) -> SbiRet {
         SbiRet::success(4)
     }
 
-    fn remote_sfence_vma(&self, _: rustsbi::HartMask, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma(&self, _: HartMask, _: usize, _: usize) -> SbiRet {
         SbiRet::success(5)
     }
 
-    fn remote_sfence_vma_asid(&self, _: rustsbi::HartMask, _: usize, _: usize, _: usize) -> SbiRet {
+    fn remote_sfence_vma_asid(&self, _: HartMask, _: usize, _: usize, _: usize) -> SbiRet {
         SbiRet::success(6)
     }
 }