provisioning: Hook up GUID-based partition type

Signed-off-by: Ikey Doherty <[email protected]>

Author: ikeycode

crates/provisioning/Cargo.toml

@@ -16,3 +16,4 @@ phf = { workspace = true, features = ["macros"] }
 test-log.workspace = true
 thiserror.workspace = true
 log.workspace = true
+uuid.workspace = true

crates/provisioning/src/commands/create_partition.rs

@@ -3,7 +3,10 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::{get_kdl_property, get_property_str, Constraints, Context, FromKdlProperty, PartitionRole};
+use crate::{
+    get_kdl_entry, get_kdl_property, get_property_str, Constraints, Context, FromKdlProperty, FromKdlType,
+    PartitionRole, PartitionTypeGuid, PartitionTypeKDL,
+};
 
 /// Command to create a partition
 #[derive(Debug)]
@@ -17,6 +20,9 @@ pub struct Command {
     /// The role, if any, of the partition
     pub role: Option<PartitionRole>,
 
+    /// The GUID of the partition type
+    pub partition_type: Option<PartitionTypeGuid>,
+
     pub constraints: Constraints,
 }
 
@@ -37,11 +43,21 @@ pub(crate) fn parse(context: Context<'_>) -> Result<super::Command, crate::Error
             return Err(crate::Error::MissingNode("constraints"));
         };
 
+    let partition_type = if let Some(partition_type) = context.node.iter_children().find(|n| n.name().value() == "type")
+    {
+        match PartitionTypeKDL::from_kdl_type(get_kdl_entry(partition_type, &0)?)? {
+            PartitionTypeKDL::GUID => Some(PartitionTypeGuid::from_kdl_node(partition_type)?),
+        }
+    } else {
+        None
+    };
+
     // TODO: Load constraints etc
     Ok(super::Command::CreatePartition(Box::new(Command {
         disk,
         id,
         role,
         constraints,
+        partition_type,
     })))
 }

crates/provisioning/src/provisioner.rs

@@ -169,7 +169,7 @@ impl Provisioner {
             }
         }
 
-        // OK lets now apply amy mutations to the device assignments
+        // OK lets now apply any mutations to the device assignments
         for (disk_name, device_plan) in device_assignments.iter_mut() {
             debug!("Applying device plan for disk {}", disk_name);
             if let Err(e) = device_plan.strategy.apply(&mut device_plan.planner) {

crates/provisioning/src/types.rs

@@ -18,6 +18,8 @@ mod units;
 pub use units::*;
 pub mod constraints;
 pub use constraints::*;
+mod partition_type;
+pub use partition_type::*;
 
 /// The type of a KDL value
 #[derive(Debug)]

crates/provisioning/src/types/partition_type.rs

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::{fmt, str::FromStr};
+
+pub use gpt::partition_types::Type as GptPartitionType;
+use partitioning::gpt;
+pub use uuid::Uuid;
+
+use crate::{get_kdl_entry, kdl_value_to_string, UnsupportedValue};
+
+use super::FromKdlType;
+
+pub enum PartitionTypeKDL {
+    GUID,
+}
+
+impl FromStr for PartitionTypeKDL {
+    type Err = crate::Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "guid" => Ok(Self::GUID),
+            _ => Err(crate::Error::UnknownVariant),
+        }
+    }
+}
+
+impl fmt::Display for PartitionTypeKDL {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::GUID => f.write_str("guid"),
+        }
+    }
+}
+
+impl<'a> FromKdlType<'a> for PartitionTypeKDL {
+    fn from_kdl_type(id: &'a kdl::KdlEntry) -> Result<Self, crate::Error> {
+        let ty_id = if let Some(ty) = id.ty() {
+            ty.value().to_lowercase()
+        } else {
+            "".into()
+        };
+
+        let v = ty_id.parse().map_err(|_| UnsupportedValue {
+            at: id.span(),
+            advice: Some("only '(GUID)' type is supported".into()),
+        })?;
+        Ok(v)
+    }
+}
+
+/// Represents GPT partition type GUIDs
+#[derive(Debug, PartialEq)]
+pub enum PartitionTypeGuid {
+    EfiSystemPartition,
+    ExtendedBootLoader,
+    LinuxSwap,
+}
+
+impl fmt::Display for PartitionTypeGuid {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::EfiSystemPartition => f.write_str("efi-system-partition"),
+            Self::ExtendedBootLoader => f.write_str("linux-extended-boot"),
+            Self::LinuxSwap => f.write_str("linux-swap"),
+        }
+    }
+}
+
+impl FromStr for PartitionTypeGuid {
+    type Err = crate::Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "efi-system-partition" => Ok(Self::EfiSystemPartition),
+            "linux-extended-boot" => Ok(Self::ExtendedBootLoader),
+            "linux-swap" => Ok(Self::LinuxSwap),
+            _ => Err(crate::Error::UnknownVariant),
+        }
+    }
+}
+
+impl PartitionTypeGuid {
+    /// Returns the GUID value for this partition type
+    pub fn as_guid(&self) -> GptPartitionType {
+        match self {
+            Self::EfiSystemPartition => gpt::partition_types::EFI,
+            Self::ExtendedBootLoader => gpt::partition_types::FREEDESK_BOOT,
+            Self::LinuxSwap => gpt::partition_types::LINUX_SWAP,
+        }
+    }
+
+    pub fn from_kdl_node(node: &kdl::KdlNode) -> Result<Self, crate::Error> {
+        let value = kdl_value_to_string(get_kdl_entry(node, &0)?)?;
+        let v = value.parse().map_err(|_| crate::UnsupportedValue {
+            at: node.span(),
+            advice: Some("'efi-system-partition', 'linux-swap', and 'linux-extended-boot' are supported".into()),
+        })?;
+        Ok(v)
+    }
+}

crates/provisioning/tests/use_whole_disk.kdl

@@ -4,7 +4,7 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
     // The result is stored in "root_disk" (disk=..)
     find-disk "root_disk" {
         constraints {
-            min (GB)30
+            min (GB)60
         }
     }
 
@@ -17,7 +17,7 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
             min (GIB)1
             max (GIB)2
         }
-        type (GUID)"ESP"
+        type (GUID)"efi-system-partition"
     }
 
     // Create xbootldr
@@ -26,7 +26,7 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
             min (GIB)2
             max (GIB)4
         }
-        type (GUID)"LinuxExtendedBoot"
+        type (GUID) "linux-extended-boot"
     }
 
     // Create a partition for rootfs
@@ -35,7 +35,6 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
             min (GIB)30
             max (GIB)120
         }
-        type (GUID)"LinuxRoot"
     }
 
     // find a partition (bound to root_disk here)
@@ -51,6 +50,6 @@ strategy name="whole_disk_with_swap" inherits="whole_disk" \
             min (GIB)4
             max (GIB)8
         }
-        type (GUID)"LinuxSwap"
+        type (GUID)"linux-swap"
     }
 }