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;
@@ -9,6 +10,8 @@ use std::collections::HashMap;
 /// HugepagesSettings contains hugepages and transparent hugepages related settings.
 #[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, HugepageConfig>,
 }
@@ -92,6 +95,86 @@ impl TryFrom<&str> for HugepageSize {
 
 string_impls_for!(HugepageSize, "HugepageSize");
 
+/// Supported transparent hugepages knobs in Bottlerocket
+#[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>,
+}
+
+/// Acceptable transparent hugepages policies
+#[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;
+    use test_case::test_case;
+
+    #[test_case("never")]
+    #[test_case("madvise")]
+    #[test_case("always")]
+    fn good_policy(input: &str) {
+        assert!(TransparentHugepagePolicy::try_from(input).is_ok());
+    }
+
+    #[test_case("disable")]
+    #[test_case("enable")]
+    #[test_case("")]
+    #[test_case("sometimes")]
+    #[test_case(&"a".repeat(64))]
+    fn bad_policy(input: &str) {
+        assert!(TransparentHugepagePolicy::try_from(input).is_err());
+    }
+}
+
+/// Acceptable transparent hugepages defragmentation policies
+#[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;
+    use test_case::test_case;
+
+    #[test_case("never")]
+    #[test_case("madvise")]
+    #[test_case("defer")]
+    #[test_case("defer+madvise")]
+    #[test_case("always")]
+    fn good_policy(input: &str) {
+        assert!(TransparentHugepageDefragPolicy::try_from(input).is_ok());
+    }
+
+    #[test_case("disable")]
+    #[test_case("enable")]
+    #[test_case("")]
+    #[test_case("sometimes")]
+    #[test_case(&"a".repeat(64))]
+    fn bad_policy(input: &str) {
+        assert!(TransparentHugepageDefragPolicy::try_from(input).is_err());
+    }
+}
+
 #[cfg(test)]
 mod test_hugepage_size {
     use super::HugepageSize;

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::{HugepageConfig, HugepageSize, NonNegativeInteger};
+    use bottlerocket_modeled_types::{
+        HugepageConfig, 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")
+        );
     }
 }