rust-for-linux.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH] rust: add new macro for common bitwise operations
@ 2025-03-04 12:55 Filipe Xavier
  2025-03-04 12:57 ` Alice Ryhl
                   ` (5 more replies)
  0 siblings, 6 replies; 14+ messages in thread
From: Filipe Xavier @ 2025-03-04 12:55 UTC (permalink / raw)
  To: Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
	Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
	Trevor Gross, Danilo Krummrich
  Cc: daniel.almeida, rust-for-linux, felipe_life, Filipe Xavier

We have seen a proliferation of mod_whatever::foo::Flags
being defined with essentially the same implementation
for bitAnd, bitOr, contains and etc.

This macro aims to bring a solution for this,
allowing to generate these methods for user-defined structs.
With some use cases in KMS and VideoCodecs.

Link: https://rust-for-linux.zulipchat.com/#narrow/channel/288089-General/topic/We.20really.20need.20a.20common.20.60Flags.60.20type
Signed-off-by: Filipe Xavier <felipeaggger@gmail.com>
---
 rust/kernel/bitmask.rs | 171 +++++++++++++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs     |   2 +
 rust/kernel/prelude.rs |   1 +
 3 files changed, 174 insertions(+)

diff --git a/rust/kernel/bitmask.rs b/rust/kernel/bitmask.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8d26a541c693a2cb60096059ecb708d895bb3ad1
--- /dev/null
+++ b/rust/kernel/bitmask.rs
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Bitmask utilities for working with flags in Rust.
+
+/// Declares a bitmask type with its corresponding flag type.
+///
+/// This macro generates:
+/// - Implementations of common bitwise operations (`BitOr`, `BitAnd`, etc.).
+/// - Utility methods such as `.contains()` to check flags.
+///
+/// # Examples
+///
+/// Defining and using a bitmask:
+/// ```
+/// bitmask!(Permissions, Permission, u32);
+///
+/// // Define some individual permissions
+/// const READ: Permission = Permission(1 << 0);
+/// const WRITE: Permission = Permission(1 << 1);
+/// const EXECUTE: Permission = Permission(1 << 2);
+///
+/// // Combine multiple permissions using bitwise OR (`|`)
+/// let read_write = Permissions::from(READ) | WRITE;
+///
+/// assert!(read_write.contains(READ));   // READ is set
+/// assert!(read_write.contains(WRITE));  // WRITE is set
+/// assert!(!read_write.contains(EXECUTE)); // EXECUTE is not set
+///
+/// // Removing a permission with bitwise AND (`&`)
+/// let read_only = read_write & READ;
+/// assert!(read_only.contains(READ)); // Still has READ
+/// assert!(!read_only.contains(WRITE)); // WRITE was removed
+///
+/// // Toggling permissions with XOR (`^`)
+/// let toggled = read_only ^ Permissions::from(READ);
+/// assert!(!toggled.contains(READ)); // READ was removed
+///
+/// // Inverting permissions with negation (`-`)
+/// let negated = -read_only;
+/// assert!(negated.contains(WRITE)); // Previously unset bits are now set
+/// ```
+#[macro_export]
+macro_rules! bitmask {
+    ($flags:ident, $flag:ident, $ty:ty) => {
+        #[allow(missing_docs)]
+        #[repr(transparent)]
+        #[derive(Copy, Clone, Default, PartialEq, Eq)]
+        pub struct $flags($ty);
+
+        #[allow(missing_docs)]
+        #[derive(Copy, Clone, PartialEq, Eq)]
+        pub struct $flag($ty);
+
+        impl From<$flag> for $flags {
+            #[inline]
+            fn from(value: $flag) -> Self {
+                Self(value.0)
+            }
+        }
+
+        impl From<$flags> for $ty {
+            #[inline]
+            fn from(value: $flags) -> Self {
+                value.0
+            }
+        }
+
+        impl core::ops::BitOr for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn bitor(self, rhs: Self) -> Self::Output {
+                Self(self.0 | rhs.0)
+            }
+        }
+
+        impl core::ops::BitOrAssign for $flags {
+            #[inline]
+            fn bitor_assign(&mut self, rhs: Self) {
+                *self = *self | rhs;
+            }
+        }
+
+        impl core::ops::BitAnd for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn bitand(self, rhs: Self) -> Self::Output {
+                Self(self.0 & rhs.0)
+            }
+        }
+
+        impl core::ops::BitAndAssign for $flags {
+            #[inline]
+            fn bitand_assign(&mut self, rhs: Self) {
+                *self = *self & rhs;
+            }
+        }
+
+        impl core::ops::BitOr<$flag> for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn bitor(self, rhs: $flag) -> Self::Output {
+                self | Self::from(rhs)
+            }
+        }
+
+        impl core::ops::BitOrAssign<$flag> for $flags {
+            #[inline]
+            fn bitor_assign(&mut self, rhs: $flag) {
+                *self = *self | rhs;
+            }
+        }
+
+        impl core::ops::BitAnd<$flag> for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn bitand(self, rhs: $flag) -> Self::Output {
+                self & Self::from(rhs)
+            }
+        }
+
+        impl core::ops::BitAndAssign<$flag> for $flags {
+            #[inline]
+            fn bitand_assign(&mut self, rhs: $flag) {
+                *self = *self & rhs;
+            }
+        }
+
+        impl core::ops::BitXor for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn bitxor(self, rhs: Self) -> Self::Output {
+                Self(self.0 ^ rhs.0)
+            }
+        }
+
+        impl core::ops::BitXorAssign for $flags {
+            #[inline]
+            fn bitxor_assign(&mut self, rhs: Self) {
+                *self = *self ^ rhs;
+            }
+        }
+
+        impl core::ops::Neg for $flags {
+            type Output = Self;
+
+            #[inline]
+            fn neg(self) -> Self::Output {
+                Self(!self.0)
+            }
+        }
+
+        impl $flags {
+            /// Returns an empty instance of <type> where no flags are set.
+            #[inline]
+            pub const fn empty() -> Self {
+                Self(0)
+            }
+
+            /// Checks if a specific flag is set.
+            #[inline]
+            pub fn contains(self, flag: $flag) -> bool {
+                (self.0 & flag.0) == flag.0
+            }
+        }
+    };
+}
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 496ed32b0911a9fdbce5d26738b9cf7ef910b269..c4c88b59d2c3d96ce4efd7e610c28211d4691ec3 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -35,6 +35,8 @@
 
 pub use ffi;
 
+pub mod bitmask;
+
 pub mod alloc;
 #[cfg(CONFIG_BLOCK)]
 pub mod block;
diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs
index dde2e0649790ca24e6c347b29465ea0a1c3e503b..2560e92aeed87e69bf0dc7c18abe81c0e45310ca 100644
--- a/rust/kernel/prelude.rs
+++ b/rust/kernel/prelude.rs
@@ -25,6 +25,7 @@
 #[doc(no_inline)]
 pub use super::dbg;
 pub use super::fmt;
+pub use super::bitmask;
 pub use super::{dev_alert, dev_crit, dev_dbg, dev_emerg, dev_err, dev_info, dev_notice, dev_warn};
 pub use super::{pr_alert, pr_crit, pr_debug, pr_emerg, pr_err, pr_info, pr_notice, pr_warn};
 

---
base-commit: beeb78d46249cab8b2b8359a2ce8fa5376b5ad2d
change-id: 20250304-feat-add-bitmask-macro-6424b1c317e2

Best regards,
-- 
Filipe Xavier <felipeaggger@gmail.com>


^ permalink raw reply related	[flat|nested] 14+ messages in thread
end of thread, other threads:[~2025-03-17 21:41 UTC | newest]

Thread overview: 14+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-03-04 12:55 [PATCH] rust: add new macro for common bitwise operations Filipe Xavier
2025-03-04 12:57 ` Alice Ryhl
2025-03-10 13:31   ` Miguel Ojeda
2025-03-17 21:36   ` Lyude Paul
2025-03-04 14:09 ` Greg KH
2025-03-05 12:46   ` Filipe Xavier
2025-03-05 14:18     ` Greg KH
2025-03-14 14:18   ` Daniel Almeida
2025-03-14 15:02     ` Greg KH
2025-03-17 15:00       ` Alice Ryhl
2025-03-10 13:33 ` Miguel Ojeda
2025-03-13  0:40 ` kernel test robot
2025-03-14 14:09 ` Daniel Almeida
2025-03-17 21:40 ` Lyude Paul

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).