feat: add support for transparent hugepages

Signed-off-by: Piyush Jena <jepiyush@amazon.com>

Author: piyush-jena

bottlerocket-settings-models/modeled-types/src/hugepages.rs

@@ -1,4 +1,5 @@
 use crate::{error, NonNegativeInteger};
+use bottlerocket_scalar_derive::Scalar;
 use bottlerocket_string_impls_for::string_impls_for;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -8,6 +9,8 @@ use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 pub struct HugepagesSettings {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transparent: Option<HugepagesTransparent>,
     #[serde(flatten)]
     pub hugepages_config: HashMap<HugepageSize, HugepagePool>,
 }
@@ -126,6 +129,75 @@ impl TryFrom<&str> for HugepageSize {
 
 string_impls_for!(HugepageSize, "HugepageSize");
 
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct HugepagesTransparent {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<TransparentHugepagePolicy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub defrag: Option<TransparentHugepageDefragPolicy>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Scalar, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum TransparentHugepagePolicy {
+    #[default]
+    Never,
+    Madvise,
+    Always,
+}
+
+#[cfg(test)]
+mod test_thp_policy {
+    use super::TransparentHugepagePolicy;
+    use std::convert::TryFrom;
+
+    #[test]
+    fn good_policy() {
+        for ok in &["never", "madvise", "always"] {
+            TransparentHugepagePolicy::try_from(*ok).unwrap();
+        }
+    }
+
+    #[test]
+    fn bad_policy() {
+        for err in &["disable", "enable", "", "sometimes", &"a".repeat(64)] {
+            TransparentHugepagePolicy::try_from(*err).unwrap_err();
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Scalar, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum TransparentHugepageDefragPolicy {
+    #[default]
+    Never,
+    Madvise,
+    Defer,
+    #[serde(rename = "defer+madvise")]
+    DeferMadvise,
+    Always,
+}
+
+#[cfg(test)]
+mod test_thp_defrag_policy {
+    use super::TransparentHugepageDefragPolicy;
+    use std::convert::TryFrom;
+
+    #[test]
+    fn good_policy() {
+        for ok in &["never", "madvise", "defer", "defer+madvise", "always"] {
+            TransparentHugepageDefragPolicy::try_from(*ok).unwrap();
+        }
+    }
+
+    #[test]
+    fn bad_policy() {
+        for err in &["disable", "enable", "", "sometimes", &"a".repeat(64)] {
+            TransparentHugepageDefragPolicy::try_from(*err).unwrap_err();
+        }
+    }
+}
+
 #[cfg(test)]
 mod test_hugepage_size {
     use super::HugepageSize;
@@ -189,7 +261,8 @@ mod test_hugepages_settings {
     #[test]
     fn pool_count_table_deserializes_and_round_trips() {
         // Nested `count` table form is the accepted shape.
-        let settings: HugepagesSettings = serde_json::from_str(r#"{"1Gi": {"count": 2}}"#).unwrap();
+        let settings: HugepagesSettings =
+            serde_json::from_str(r#"{"1Gi": {"count": 2}}"#).unwrap();
         let key = HugepageSize::try_from("1Gi").unwrap();
         let pool = settings.hugepages_config.get(&key).expect("1Gi pool");
         assert_eq!(*pool.count, 2);
@@ -217,6 +290,32 @@ mod test_hugepages_settings {
         assert!(result.is_err(), "unknown pool field should be rejected");
     }
 
+    #[test]
+    fn transparent_round_trips_alongside_pools() {
+        let json = r#"{
+            "transparent": {"enabled": "always", "defrag": "madvise"},
+            "2Mi": {"count": 512},
+            "1Gi": {"count": 4}
+        }"#;
+        let settings: HugepagesSettings = serde_json::from_str(json).unwrap();
+
+        let two_mi = HugepageSize::try_from("2Mi").unwrap();
+        let one_gi = HugepageSize::try_from("1Gi").unwrap();
+        assert_eq!(*settings.hugepages_config[&two_mi].count, 512);
+        assert_eq!(*settings.hugepages_config[&one_gi].count, 4);
+
+        let transparent = settings.transparent.as_ref().expect("transparent");
+        assert!(transparent.enabled.is_some());
+        assert!(transparent.defrag.is_some());
+
+        // Round-trips: the pools serialize back as nested count tables and `transparent` stays.
+        let out = serde_json::to_value(&settings).unwrap();
+        assert_eq!(out["2Mi"]["count"], 512);
+        assert_eq!(out["1Gi"]["count"], 4);
+        assert_eq!(out["transparent"]["enabled"], "always");
+        assert_eq!(out["transparent"]["defrag"], "madvise");
+    }
+
     #[test]
     fn construct_pool_directly() {
         let pool = HugepagePool {

bottlerocket-settings-models/settings-extensions/kernel/src/lib.rs

@@ -53,7 +53,10 @@ impl SettingsModel for KernelSettingsV1 {
 #[cfg(test)]
 mod test {
     use super::*;
-    use bottlerocket_modeled_types::{HugepagePool, HugepageSize, NonNegativeInteger};
+    use bottlerocket_modeled_types::{
+        HugepagePool, HugepageSize, HugepagesTransparent, NonNegativeInteger,
+        TransparentHugepageDefragPolicy, TransparentHugepagePolicy,
+    };
 
     #[test]
     fn test_generate_kernel() {
@@ -78,7 +81,8 @@ mod test {
             "sysctl": {"key": "value"},
             "hugepages": {
                 "2Mi": {"count": 512},
-                "1Gi": {"count": 4}
+                "1Gi": {"count": 4},
+                "transparent": {"enabled": "always", "defrag": "defer+madvise"}
             }
         }"#;
 
@@ -112,7 +116,13 @@ mod test {
             },
         );
 
-        let hugepages = Some(HugepagesSettings { hugepages_config });
+        let hugepages = Some(HugepagesSettings {
+            transparent: Some(HugepagesTransparent {
+                enabled: Some(TransparentHugepagePolicy::try_from("always").unwrap()),
+                defrag: Some(TransparentHugepageDefragPolicy::try_from("defer+madvise").unwrap()),
+            }),
+            hugepages_config,
+        });
 
         assert_eq!(
             kernel,
@@ -128,5 +138,13 @@ mod test {
         let hugepages_out = &roundtrip["hugepages"];
         assert_eq!(hugepages_out["2Mi"]["count"], serde_json::json!(512));
         assert_eq!(hugepages_out["1Gi"]["count"], serde_json::json!(4));
+        assert_eq!(
+            hugepages_out["transparent"]["enabled"],
+            serde_json::json!("always")
+        );
+        assert_eq!(
+            hugepages_out["transparent"]["defrag"],
+            serde_json::json!("defer+madvise")
+        );
     }
 }