Introduce the `num` module, featuring the `NumExt` extension trait
that expands unsigned integers with useful operations for the kernel.
These are to be used by the nova-core driver, but they are so ubiquitous
that other drivers should be able to take advantage of them as well.
The currently implemented operations are:
- align_down()
- align_up()
- fls()
But this trait is expected to be expanded further.
`NumExt` is on unsigned types using a macro. An approach using another
trait constrained by the operator traits that we need (`Add`, `Sub`,
etc) was also considered, but had to be dropped as we need to use
wrapping operations, which are not provided by any trait.
Co-developed-by: Joel Fernandes <joelagn...@nvidia.com>
Signed-off-by: Joel Fernandes <joelagn...@nvidia.com>
Signed-off-by: Alexandre Courbot <acour...@nvidia.com>
---
rust/kernel/lib.rs | 1 +
rust/kernel/num.rs | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 83 insertions(+)
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index
ab0286857061d2de1be0279cbd2cd3490e5a48c3..be75b196aa7a29cf3eed7c902ed8fb98689bbb50
100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -67,6 +67,7 @@
pub mod miscdevice;
#[cfg(CONFIG_NET)]
pub mod net;
+pub mod num;
pub mod of;
pub mod page;
#[cfg(CONFIG_PCI)]
diff --git a/rust/kernel/num.rs b/rust/kernel/num.rs
new file mode 100644
index
0000000000000000000000000000000000000000..05d45b59313d830876c1a7b452827689a6dd5400
--- /dev/null
+++ b/rust/kernel/num.rs
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Numerical and binary utilities for primitive types.
+
+/// Extension trait providing useful methods for the kernel on integers.
+pub trait NumExt {
+ /// Align `self` down to `alignment`.
+ ///
+ /// `alignment` must be a power of 2 for accurate results.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use kernel::num::NumExt;
+ ///
+ /// assert_eq!(0x4fffu32.align_down(0x1000), 0x4000);
+ /// assert_eq!(0x4fffu32.align_down(0x0), 0x0);
+ /// ```
+ fn align_down(self, alignment: Self) -> Self;
+
+ /// Align `self` up to `alignment`.
+ ///
+ /// `alignment` must be a power of 2 for accurate results.
+ ///
+ /// Wraps around to `0` if the requested alignment pushes the result above
the type's limits.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use kernel::num::NumExt;
+ ///
+ /// assert_eq!(0x4fffu32.align_up(0x1000), 0x5000);
+ /// assert_eq!(0x4000u32.align_up(0x1000), 0x4000);
+ /// assert_eq!(0x0u32.align_up(0x1000), 0x0);
+ /// assert_eq!(0xffffu16.align_up(0x100), 0x0);
+ /// assert_eq!(0x4fffu32.align_up(0x0), 0x0);
+ /// ```
+ fn align_up(self, alignment: Self) -> Self;
+
+ /// Find Last Set Bit: return the 1-based index of the last (i.e. most
significant) set bit in
+ /// `self`.
+ ///
+ /// Equivalent to the C `fls` function.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use kernel::num::NumExt;
+ ///
+ /// assert_eq!(0x0u32.fls(), 0);
+ /// assert_eq!(0x1u32.fls(), 1);
+ /// assert_eq!(0x10u32.fls(), 5);
+ /// assert_eq!(0xffffu32.fls(), 16);
+ /// assert_eq!(0x8000_0000u32.fls(), 32);
+ /// ```
+ fn fls(self) -> u32;
+}
+
+macro_rules! numext_impl {
+ ($($t:ty),+) => {
+ $(
+ impl NumExt for $t {
+ #[inline]
+ fn align_down(self, alignment: Self) -> Self {
+ self & !alignment.wrapping_sub(1)
+ }
+
+ #[inline]
+ fn align_up(self, alignment: Self) -> Self {
+
self.wrapping_add(alignment.wrapping_sub(1)).align_down(alignment)
+ }
+
+ #[inline]
+ fn fls(self) -> u32 {
+ Self::BITS - self.leading_zeros()
+ }
+ }
+ )+
+ };
+}
+
+numext_impl!(usize, u8, u16, u32, u64, u128);
--
2.49.0
