fixup! rust: netlink: add raw netlink abstraction

Author: Darksonn

rust/kernel/netlink.rs

@@ -144,6 +144,29 @@ impl Drop for GenlMsg {
     }
 }
 
+/// Flags for a generic netlink family.
+struct FamilyFlags {
+    /// Whether the family supports network namespaces.
+    netnsok: bool,
+    /// Whether the family supports parallel operations.
+    parallel_ops: bool,
+}
+
+impl FamilyFlags {
+    /// Converts the flags to the bitfield representation used by `genl_family`.
+    const fn into_bitfield(self) -> bindings::__BindgenBitfieldUnit<[u8; 1]> {
+        let mut bits = 0;
+        if self.netnsok {
+            bits |= 1 << 0;
+        }
+        if self.parallel_ops {
+            bits |= 1 << 1;
+        }
+        // SAFETY: This bitfield is represented as an u8.
+        unsafe { core::mem::transmute::<u8, bindings::__BindgenBitfieldUnit<[u8; 1]>>(bits) }
+    }
+}
+
 /// A generic netlink family.
 #[repr(transparent)]
 pub struct Family {
@@ -167,10 +190,11 @@ impl Family {
         }
         let mut genl_family = bindings::genl_family {
             version,
-            // SAFETY: This bitfield is represented as an u8.
-            _bitfield_1: unsafe {
-                core::mem::transmute::<u8, bindings::__BindgenBitfieldUnit<[u8; 1]>>(0b11u8)
-            },
+            _bitfield_1: FamilyFlags {
+                netnsok: true,
+                parallel_ops: true,
+            }
+            .into_bitfield(),
             module: module.as_ptr(),
             mcgrps: mcgrps.as_ptr().cast(),
             n_mcgrps,
@@ -242,7 +266,7 @@ impl MulticastGroup {
 ///
 /// # Invariants
 ///
-/// `self.family` always holds a valid reference to an initialized and registered [`genl_family`].
+/// `self.family` always holds a valid reference to an initialized and registered [`Family`].
 pub struct Registration {
     family: &'static Family,
 }
@@ -265,3 +289,37 @@ impl Drop for Registration {
         unsafe { bindings::genl_unregister_family(self.family.as_raw()) };
     }
 }
+
+#[macros::kunit_tests(rust_netlink)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_family_flags_bitfield() {
+        for netnsok in [false, true] {
+            for parallel_ops in [false, true] {
+                let mut b_fam = bindings::genl_family {
+                    ..Default::default()
+                };
+                b_fam.set_netnsok(if netnsok { 1 } else { 0 });
+                b_fam.set_parallel_ops(if parallel_ops { 1 } else { 0 });
+
+                let c_bitfield = FamilyFlags {
+                    netnsok,
+                    parallel_ops,
+                }
+                .into_bitfield();
+
+                // SAFETY: The bit field is stored as u8.
+                let b_val: u8 = unsafe { core::mem::transmute(b_fam._bitfield_1) };
+                // SAFETY: The bit field is stored as u8.
+                let c_val: u8 = unsafe { core::mem::transmute(c_bitfield) };
+                assert_eq!(
+                    b_val, c_val,
+                    "Failed for netnsok={} parallel_ops={}",
+                    netnsok, parallel_ops
+                );
+            }
+        }
+    }
+}