partitioning: Add new attributes for gpt tagging

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

Author: ikeycode

crates/partitioning/Cargo.toml

@@ -10,6 +10,7 @@ thiserror.workspace = true
 log.workspace = true
 gpt.workspace = true
 nix.workspace = true
+uuid.workspace = true
 linux-raw-sys = { workspace = true, features = ["loop_device", "ioctl"] }
 
 [dev-dependencies]

crates/partitioning/src/attributes.rs

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use gpt::partition_types;
+use uuid::Uuid;
+
+/// Represents the attributes of a GPT partition
+#[derive(Debug, Clone)]
+pub struct GptAttributes {
+    /// The type GUID that identifies the partition type
+    pub type_guid: partition_types::Type,
+    /// Optional name for the partition
+    pub name: Option<String>,
+    /// Optional UUID for the partition
+    pub uuid: Option<Uuid>,
+}
+
+impl Default for GptAttributes {
+    fn default() -> Self {
+        Self {
+            type_guid: partition_types::BASIC,
+            name: None,
+            uuid: None,
+        }
+    }
+}
+
+/// Represents attributes specific to different partition table types
+#[derive(Debug, Clone)]
+pub enum PartitionAttributes {
+    /// GPT partition attributes
+    Gpt(GptAttributes),
+    //Mbr(MbrAttributes),
+}
+
+impl PartitionAttributes {
+    /// Returns a reference to the GPT attributes if this is a GPT partition
+    ///
+    /// # Returns
+    /// - `Some(&GptAttributes)` if this is a GPT partition
+    /// - `None` if this is not a GPT partition
+    pub fn as_gpt(&self) -> Option<&GptAttributes> {
+        match self {
+            PartitionAttributes::Gpt(attr) => Some(attr),
+        }
+    }
+}

crates/partitioning/src/lib.rs

@@ -6,6 +6,9 @@ pub mod blkpg;
 pub mod loopback;
 pub mod sparsefile;
 
+mod attributes;
+pub use attributes::*;
+
 pub use gpt;
 
 pub mod planner;

crates/partitioning/src/planner.rs

@@ -17,6 +17,8 @@ use log::{debug, warn};
 use std::collections::VecDeque;
 use thiserror::Error;
 
+use crate::PartitionAttributes;
+
 /// Errors that can occur while planning partition changes
 ///
 /// These errors help prevent invalid partition layouts by catching problems
@@ -39,7 +41,12 @@ pub enum PlanError {
 #[derive(Debug, Clone)]
 pub enum Change {
     /// Add a new partition
-    AddPartition { start: u64, end: u64, partition_id: u32 },
+    AddPartition {
+        start: u64,
+        end: u64,
+        partition_id: u32,
+        attributes: Option<PartitionAttributes>,
+    },
     /// Delete an existing partition
     DeletePartition { original_index: usize, partition_id: u32 },
 }
@@ -203,6 +210,7 @@ impl Change {
                 start,
                 end,
                 partition_id,
+                ..
             } => {
                 format!(
                     "Add new partition #{}: {} ({} at {})",
@@ -311,6 +319,7 @@ impl Planner {
                 start,
                 end,
                 partition_id,
+                ..
             } = change
             {
                 debug!("Adding partition {}..{} (ID: {})", start, end, partition_id);
@@ -326,6 +335,10 @@ impl Planner {
         layout
     }
 
+    pub fn plan_add_partition(&mut self, start: u64, end: u64) -> Result<(), PlanError> {
+        self.plan_add_partition_with_attributes(start, end, None)
+    }
+
     /// Plan to add a new partition between two absolute positions on disk.
     ///
     /// # Arguments
@@ -335,7 +348,12 @@ impl Planner {
     /// Both positions will be aligned to the nearest appropriate boundary (usually 1MB).
     /// The partition will occupy the range [start, end).
     ///
-    pub fn plan_add_partition(&mut self, start: u64, end: u64) -> Result<(), PlanError> {
+    pub fn plan_add_partition_with_attributes(
+        &mut self,
+        start: u64,
+        end: u64,
+        attributes: Option<PartitionAttributes>,
+    ) -> Result<(), PlanError> {
         debug!("Planning to add partition {}..{}", start, end);
         debug!("Original size requested: {}", end - start);
 
@@ -401,6 +419,7 @@ impl Planner {
             start: aligned_start,
             end: aligned_end,
             partition_id,
+            attributes,
         });
         Ok(())
     }

crates/partitioning/src/strategy.rs

@@ -20,15 +20,18 @@
 //! // Request needed partitions
 //! strategy.add_request(PartitionRequest {
 //!     size: SizeRequirement::Exact(512 * 1024 * 1024), // 512MB EFI partition
+//!     attributes: None,
 //! });
 //! strategy.add_request(PartitionRequest {
 //!     size: SizeRequirement::Remaining, // Rest for root
+//!     attributes: None,
 //! });
 //! ```
 
 use crate::planner::{PlanError, Planner};
 
 use crate::planner::Region;
+use crate::PartitionAttributes;
 
 /// Strategy for allocating partitions
 #[derive(Debug, Clone)]
@@ -61,6 +64,7 @@ pub enum SizeRequirement {
 #[derive(Debug, Clone)]
 pub struct PartitionRequest {
     pub size: SizeRequirement,
+    pub attributes: Option<PartitionAttributes>,
 }
 
 /// Handles planning partition layouts according to specific strategies
@@ -201,15 +205,15 @@ impl Strategy {
         // First pass: allocate exact size partitions
         for request in &self.requests {
             if let SizeRequirement::Exact(size) = request.size {
-                planner.plan_add_partition(current, current + size)?;
+                planner.plan_add_partition_with_attributes(current, current + size, request.attributes.clone())?;
                 current += size;
                 remaining -= size;
             }
         }
 
         // Second pass: allocate flexible partitions
         let mut remaining_flexible = flexible_requests.len();
-        for (_idx, min, max_opt) in &flexible_requests {
+        for (idx, min, max_opt) in &flexible_requests {
             remaining_flexible -= 1;
 
             // First verify we have enough space for minimum requirement
@@ -243,7 +247,11 @@ impl Strategy {
                 }
             };
 
-            match planner.plan_add_partition(current, current + size) {
+            match planner.plan_add_partition_with_attributes(
+                current,
+                current + size,
+                self.requests.get(*idx).and_then(|r| r.attributes.clone()),
+            ) {
                 Ok(_) => {
                     current += size;
                     remaining -= size;
@@ -284,6 +292,7 @@ mod tests {
     fn root_partition() -> PartitionRequest {
         PartitionRequest {
             size: SizeRequirement::AtLeast(ROOT_MIN),
+            attributes: None,
         }
     }
 
@@ -294,20 +303,23 @@ mod tests {
                 min: ROOT_MIN,
                 max: ROOT_MAX,
             },
+            attributes: None,
         }
     }
 
     /// Creates a standard EFI system partition request
     fn efi_partition() -> PartitionRequest {
         PartitionRequest {
             size: SizeRequirement::Exact(EFI_SIZE),
+            attributes: None,
         }
     }
 
     /// Creates a /boot partition request
     fn boot_partition() -> PartitionRequest {
         PartitionRequest {
             size: SizeRequirement::Exact(BOOT_SIZE),
+            attributes: None,
         }
     }
 
@@ -318,13 +330,15 @@ mod tests {
                 min: SWAP_MIN,
                 max: SWAP_MAX,
             },
+            attributes: None,
         }
     }
 
     /// Creates a home partition request that uses all remaining space
     fn home_partition() -> PartitionRequest {
         PartitionRequest {
             size: SizeRequirement::Remaining,
+            attributes: None,
         }
     }
     fn create_test_disk() -> MockDisk {
@@ -395,6 +409,7 @@ mod tests {
         strategy.add_request(boot_partition());
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::Remaining,
+            attributes: None,
         });
 
         eprintln!("\nMinimal Server Strategy:\n{}", strategy.describe());
@@ -414,6 +429,7 @@ mod tests {
         // Try to allocate more than available
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::Exact(20 * GB),
+            attributes: None,
         });
 
         assert!(strategy.apply(&mut planner).is_err());
@@ -428,9 +444,11 @@ mod tests {
         // Request more than available in flexible partitions
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::AtLeast(6 * GB),
+            attributes: None,
         });
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::AtLeast(6 * GB),
+            attributes: None,
         });
 
         // Should fail because total minimum (12GB) exceeds disk size (10GB)
@@ -448,18 +466,21 @@ mod tests {
         // Request sequence where first two would fit but third won't
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::Range { min: GB, max: 2 * GB },
+            attributes: None,
         });
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::Range {
                 min: 2 * GB,
                 max: 4 * GB,
             },
+            attributes: None,
         });
         strategy.add_request(PartitionRequest {
             size: SizeRequirement::Range {
                 min: 25 * GB,
                 max: 120 * GB,
             },
+            attributes: None,
         });
 
         // Should fail and undo partial changes

crates/partitioning/src/writer.rs

@@ -9,7 +9,10 @@ use disks::BlockDevice;
 use gpt::{mbr, partition_types, GptConfig};
 use thiserror::Error;
 
-use crate::planner::{Change, Planner};
+use crate::{
+    planner::{Change, Planner},
+    GptAttributes,
+};
 
 /// Errors that can occur when writing changes to disk
 #[derive(Debug, Error)]
@@ -139,12 +142,19 @@ impl<'a> DiskWriter<'a> {
                     start,
                     end,
                     partition_id,
+                    attributes,
                 } => {
                     let start_lba = *start / 512;
                     let size_lba = (*end - *start) / 512;
-                    let part_type = partition_types::BASIC;
-
-                    let id = gpt_table.add_partition_at("", *partition_id, start_lba, size_lba, part_type, 0)?;
+                    let (part_type, part_name) = match attributes.as_ref().and_then(|a| a.as_gpt()) {
+                        Some(GptAttributes { type_guid, name, .. }) => {
+                            (type_guid.clone(), name.clone().unwrap_or_default())
+                        }
+                        None => (partition_types::BASIC, "".to_string()),
+                    };
+
+                    let id =
+                        gpt_table.add_partition_at(&part_name, *partition_id, start_lba, size_lba, part_type, 0)?;
                     println!("Added partition {}: {:?}", partition_id, id);
                 }
             }