provisioning: Propogate GPT attributes

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

Author: ikeycode

crates/provisioning/src/commands/create_partition.rs

@@ -3,6 +3,8 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+use partitioning::{gpt::partition_types, GptAttributes, PartitionAttributes};
+
 use crate::{
     get_kdl_entry, get_kdl_property, get_property_str, Constraints, Context, Filesystem, FromKdlProperty, FromKdlType,
     PartitionRole, PartitionTypeGuid, PartitionTypeKDL,
@@ -30,6 +32,19 @@ pub struct Command {
     pub filesystem: Option<Filesystem>,
 }
 
+impl Command {
+    pub fn attributes(&self) -> PartitionAttributes {
+        PartitionAttributes::Gpt(GptAttributes {
+            type_guid: match &self.partition_type {
+                Some(p) => p.as_guid(),
+                None => partition_types::BASIC,
+            },
+            name: self.partition_type.as_ref().map(|p| p.to_string()),
+            uuid: None,
+        })
+    }
+}
+
 /// Generate a command to create a partition
 pub(crate) fn parse(context: Context<'_>) -> Result<super::Command, crate::Error> {
     let disk = get_property_str(context.node, "disk")?;

crates/provisioning/src/provisioner.rs

@@ -163,6 +163,7 @@ impl Provisioner {
                                 Constraints::Range { min, max } => SizeRequirement::Range { min: *min, max: *max },
                                 _ => SizeRequirement::Remaining,
                             },
+                            attributes: Some(command.attributes()),
                         });
                     } else {
                         warn!("Could not find disk {} to create partition", command.disk);

crates/provisioning/src/types/partition_type.rs

@@ -58,14 +58,16 @@ pub enum PartitionTypeGuid {
     EfiSystemPartition,
     ExtendedBootLoader,
     LinuxSwap,
+    LinuxFilesystem,
 }
 
 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"),
+            Self::EfiSystemPartition => f.write_str("EFI System Partition"),
+            Self::ExtendedBootLoader => f.write_str("Linux Extended Boot"),
+            Self::LinuxFilesystem => f.write_str("Linux Filesystem"),
+            Self::LinuxSwap => f.write_str("Linux Swap"),
         }
     }
 }
@@ -78,6 +80,7 @@ impl FromStr for PartitionTypeGuid {
             "efi-system-partition" => Ok(Self::EfiSystemPartition),
             "linux-extended-boot" => Ok(Self::ExtendedBootLoader),
             "linux-swap" => Ok(Self::LinuxSwap),
+            "linux-fs" => Ok(Self::LinuxFilesystem),
             _ => Err(crate::Error::UnknownVariant),
         }
     }
@@ -90,14 +93,17 @@ impl PartitionTypeGuid {
             Self::EfiSystemPartition => gpt::partition_types::EFI,
             Self::ExtendedBootLoader => gpt::partition_types::FREEDESK_BOOT,
             Self::LinuxSwap => gpt::partition_types::LINUX_SWAP,
+            Self::LinuxFilesystem => gpt::partition_types::LINUX_FS,
         }
     }
 
     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()),
+            advice: Some(
+                "'efi-system-partition', 'linux-swap' 'linux-extended-boot' and 'linux-fs' are supported".into(),
+            ),
         })?;
         Ok(v)
     }

crates/provisioning/tests/use_whole_disk.kdl

@@ -43,6 +43,7 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
             min (GiB)25
             max (GiB)120
         }
+        type (GUID)"linux-fs"
         filesystem {
             type "any"
             label "ROOT"