Multiple fies to make partitioning now *mostly* work

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

Author: ikeycode

crates/partitioning/src/planner.rs

@@ -445,7 +445,7 @@ impl Planner {
 
     /// Clear all planned changes
     pub fn reset(&mut self) {
-        debug!("Resetting all planned changes");
+        eprintln!("Resetting all planned changes");
         self.changes.clear();
     }
 

crates/partitioning/src/writer.rs

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use std::fs;
+use std::{fs, io::Write};
 
 use disks::BlockDevice;
 use gpt::{mbr, partition_types, GptConfig};
@@ -14,10 +14,6 @@ use crate::planner::{Change, Planner};
 /// Errors that can occur when writing changes to disk
 #[derive(Debug, Error)]
 pub enum WriteError {
-    /// Device size has changed since the plan was created
-    #[error("Device size changed since planning")]
-    DeviceSizeChanged,
-
     /// A partition ID was used multiple times
     #[error("Duplicate partition ID: {0}")]
     DuplicatePartitionId(u32),
@@ -55,7 +51,7 @@ impl<'a> DiskWriter<'a> {
             .read(true)
             .write(false)
             .open(self.device.device())?;
-        self.validate_changes(&device)?;
+        self.validate_changes()?;
         self.apply_changes(&mut device, false)?;
         Ok(())
     }
@@ -67,21 +63,16 @@ impl<'a> DiskWriter<'a> {
             .write(true)
             .open(self.device.device())?;
 
-        self.validate_changes(&device)?;
+        self.validate_changes()?;
         self.apply_changes(&mut device, true)?;
+        device.flush()?;
         Ok(())
     }
 
     /// Validate all planned changes before applying them by checking:
     /// - Device size matches the planned size
     /// - No duplicate partition IDs exist
-    fn validate_changes(&self, device: &fs::File) -> Result<(), WriteError> {
-        // Verify device size matches what we planned for
-        let metadata = device.metadata()?;
-        if metadata.len() != self.device.size() {
-            return Err(WriteError::DeviceSizeChanged);
-        }
-
+    fn validate_changes(&self) -> Result<(), WriteError> {
         // Verify partition IDs don't conflict
         let mut used_ids = std::collections::HashSet::new();
         for change in self.planner.changes() {
@@ -109,20 +100,28 @@ impl<'a> DiskWriter<'a> {
                 let mbr = mbr::ProtectiveMBR::with_lb_size(
                     u32::try_from((self.device.size() / 512) - 1).unwrap_or(0xFF_FF_FF_FF),
                 );
+                eprintln!("size is {}", self.device.size());
                 mbr.overwrite_lba0(device)?;
             }
 
-            GptConfig::default()
+            let mut c = GptConfig::default()
                 .writable(writable)
                 .logical_block_size(gpt::disk::LogicalBlockSize::Lb512)
-                .create_from_device(device, None)?
+                .create_from_device(device, None)?;
+
+            if writable {
+                c.write_inplace()?;
+            }
+            c
         } else {
             GptConfig::default().writable(writable).open_from_device(device)?
         };
 
         let layout = self.planner.current_layout();
         let changes = self.planner.changes();
 
+        eprintln!("Changes: {:?}", changes);
+
         for change in changes {
             match change {
                 Change::DeletePartition {
@@ -151,7 +150,7 @@ impl<'a> DiskWriter<'a> {
             }
         }
 
-        eprintln!("GPT is now: {gpt_table:?}");
+        eprintln!("### GPT is now: {gpt_table:?}");
 
         for region in layout.iter() {
             eprintln!(
@@ -160,6 +159,10 @@ impl<'a> DiskWriter<'a> {
             );
         }
 
+        if writable {
+            gpt_table.write_inplace()?;
+        }
+
         Ok(())
     }
 }

crates/provisioning/src/provisioner.rs

@@ -8,7 +8,7 @@ use std::collections::HashMap;
 use disks::BlockDevice;
 use log::{debug, info, trace, warn};
 use partitioning::{
-    planner::Planner,
+    planner::{Planner, PARTITION_ALIGNMENT},
     strategy::{AllocationStrategy, PartitionRequest, SizeRequirement, Strategy},
 };
 
@@ -31,9 +31,9 @@ pub struct Plan<'a> {
 
 #[derive(Debug, Clone)]
 pub struct DevicePlan<'a> {
-    device: &'a BlockDevice,
-    planner: Planner,
-    strategy: Strategy,
+    pub device: &'a BlockDevice,
+    pub planner: Planner,
+    pub strategy: Strategy,
 }
 
 impl Default for Provisioner {
@@ -134,7 +134,9 @@ impl Provisioner {
                             command.name.clone(),
                             DevicePlan {
                                 device,
-                                planner: Planner::new(device),
+                                planner: Planner::new(device)
+                                    .with_start_offset(PARTITION_ALIGNMENT)
+                                    .with_end_offset(device.size() - PARTITION_ALIGNMENT),
                                 strategy: Strategy::new(AllocationStrategy::LargestFree),
                             },
                         );

crates/provisioning/tests/use_whole_disk.kdl

@@ -40,28 +40,12 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
     // Create a partition for rootfs
     create-partition disk="root_disk" id="root" role="root" {
         constraints {
-            min (GiB)30
+            min (GiB)25
             max (GiB)120
         }
         filesystem {
             type "any"
             label "ROOT"
         }
     }
-
-    // find a partition (bound to root_disk here)
-    // find-partition guid="$ESP"
-}
-
-strategy name="whole_disk_with_swap" inherits="whole_disk" \
-    summary="Wipe disk, include a swap" \
-{
-    // Create a swap partition in addition to the base strategy
-    create-partition disk="root_disk" id="swap" role="swap" {
-        constraints {
-            min (GiB)4
-            max (GiB)8
-        }
-        type (GUID)"linux-swap"
-    }
 }