partitioning: Implement BLKPG reload of partition tables with GPT

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

Author: ikeycode

crates/partitioning/Cargo.toml

@@ -5,5 +5,9 @@ edition = "2021"
 description = "A library for working directly with partitions"
 
 [dependencies]
+disks = { path = "../disks" }
+thiserror.workspace = true
+log.workspace = true
+gpt.workspace = true
 nix.workspace = true
-linux-raw-sys = { workspace = true, features = ["loop_device"] }
+linux-raw-sys = { workspace = true, features = ["loop_device", "ioctl"] }

crates/partitioning/src/lib.rs

@@ -2,5 +2,187 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+/// Provides functionality for managing block device partitions
 pub mod loopback;
 pub mod sparsefile;
+
+use disks::{BasicDisk, DiskInit};
+use log::{debug, error, info, warn};
+use std::{
+    fs::File,
+    io,
+    os::fd::{AsFd, AsRawFd},
+    path::{Path, PathBuf},
+};
+use thiserror::Error;
+
+pub use gpt;
+use linux_raw_sys::ioctl::BLKPG;
+use nix::libc;
+
+/// Errors that can occur during partition operations
+#[derive(Error, Debug)]
+pub enum Error {
+    /// IO operation error
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+    /// GPT-specific error
+    #[error("GPT error: {0}")]
+    Gpt(#[from] gpt::GptError),
+}
+
+/// Represents a block device partition for IOCTL operations
+#[repr(C)]
+struct BlkpgPartition {
+    start: i64,
+    length: i64,
+    pno: i32,
+    devname: [u8; 64],
+    volname: [u8; 64],
+}
+
+/// IOCTL structure for partition operations
+#[repr(C)]
+struct BlkpgIoctl {
+    op: i32,
+    flags: i32,
+    datalen: i32,
+    data: *mut BlkpgPartition,
+}
+
+const BLKPG_ADD_PARTITION: i32 = 1;
+const BLKPG_DEL_PARTITION: i32 = 2;
+
+/// Adds a new partition to the specified block device
+///
+/// # Arguments
+/// * `fd` - File descriptor for the block device
+/// * `partition_number` - Number to assign to the new partition
+/// * `start` - Starting offset in bytes
+/// * `length` - Length of partition in bytes
+///
+/// # Returns
+/// `io::Result<()>` indicating success or failure
+pub(crate) fn add_partition<F>(fd: F, partition_number: i32, start: i64, length: i64) -> io::Result<()>
+where
+    F: AsRawFd,
+{
+    info!(
+        "➕ Adding partition {} (start: {}, length: {})",
+        partition_number, start, length
+    );
+    let mut part = BlkpgPartition {
+        start,
+        length,
+        pno: partition_number,
+        devname: [0; 64],
+        volname: [0; 64],
+    };
+
+    let mut ioctl = BlkpgIoctl {
+        op: BLKPG_ADD_PARTITION,
+        flags: 0,
+        datalen: std::mem::size_of::<BlkpgPartition>() as i32,
+        data: &mut part,
+    };
+
+    let res = unsafe { libc::ioctl(fd.as_raw_fd(), BLKPG as _, &mut ioctl) };
+    if res < 0 {
+        let err = io::Error::last_os_error();
+        error!("❌ Failed to add partition: {}", err);
+        return Err(err);
+    }
+    info!("✅ Successfully added partition {}", partition_number);
+    Ok(())
+}
+
+/// Deletes a partition from the specified block device
+///
+/// # Arguments
+/// * `fd` - File descriptor for the block device
+/// * `partition_number` - Number of the partition to delete
+///
+/// # Returns
+/// `io::Result<()>` indicating success or failure
+pub(crate) fn delete_partition<F>(fd: F, partition_number: i32) -> io::Result<()>
+where
+    F: AsRawFd,
+{
+    warn!("🗑️ Attempting to delete partition {}", partition_number);
+    let mut part = BlkpgPartition {
+        start: 0,
+        length: 0,
+        pno: partition_number,
+        devname: [0; 64],
+        volname: [0; 64],
+    };
+
+    let mut ioctl = BlkpgIoctl {
+        op: BLKPG_DEL_PARTITION,
+        flags: 0,
+        datalen: std::mem::size_of::<BlkpgPartition>() as i32,
+        data: &mut part,
+    };
+
+    let res = unsafe { libc::ioctl(fd.as_raw_fd(), BLKPG as _, &mut ioctl) };
+    if res < 0 {
+        let err = io::Error::last_os_error();
+        error!("❌ Failed to delete partition {}: {}", partition_number, err);
+        return Err(err);
+    }
+    info!("✅ Successfully deleted partition {}", partition_number);
+    Ok(())
+}
+
+/// Updates kernel partition representations to match the GPT table
+///
+/// # Arguments
+/// * `path` - Path to the block device
+///
+/// # Returns
+/// `Result<(), Error>` indicating success or partition operation failure
+pub fn sync_gpt_partitions<P: AsRef<Path>>(path: P) -> Result<(), Error> {
+    info!("🔄 Syncing GPT partitions for {:?}", path.as_ref());
+    let file = File::open(&path)?;
+
+    // Read GPT table
+    debug!("📖 Reading GPT table...");
+    let gpt = gpt::GptConfig::new().writable(false).open(&path)?;
+    let partitions = gpt.partitions();
+    let block_size = 512;
+    info!(
+        "📊 Found {} partitions with block size {}",
+        partitions.len(),
+        block_size
+    );
+
+    warn!("🗑️  Deleting existing partitions...");
+
+    // Find the disk for enumeration purposes
+    let base_name = path
+        .as_ref()
+        .file_name()
+        .ok_or(Error::Io(io::Error::from(io::ErrorKind::InvalidInput)))?
+        .to_string_lossy()
+        .to_string();
+    let disk = BasicDisk::from_sysfs_path(&PathBuf::from("/sys/class/block"), &base_name)
+        .ok_or(Error::Io(io::Error::from(io::ErrorKind::InvalidInput)))?;
+
+    for partition in disk.partitions() {
+        let _ = delete_partition(file.as_raw_fd(), partition.number as i32);
+    }
+
+    // Add partitions from GPT
+    info!("➕ Adding new partitions from GPT...");
+    for (i, partition) in partitions.iter() {
+        add_partition(
+            file.as_fd(),
+            *i as i32,
+            partition.first_lba as i64 * block_size,
+            (partition.last_lba - partition.first_lba + 1) as i64 * block_size,
+        )?;
+    }
+
+    info!("✨ GPT partition sync completed successfully");
+    Ok(())
+}

crates/partitioning/src/loopback.rs

@@ -8,6 +8,7 @@ use std::{
 };
 
 use linux_raw_sys::loop_device::{LOOP_CLR_FD, LOOP_CTL_GET_FREE, LOOP_SET_FD, LOOP_SET_STATUS64};
+use log::{debug, error, info, warn};
 use nix::libc;
 
 /// Represents a loop device that can be used to mount files as block devices
@@ -27,17 +28,21 @@ impl LoopDevice {
     pub fn create() -> io::Result<Self> {
         use std::fs::OpenOptions;
 
+        debug!("🔄 Opening loop control device");
         let ctrl = OpenOptions::new().read(true).write(true).open("/dev/loop-control")?;
 
         // Get next free loop device number
         let devno = unsafe { libc::ioctl(ctrl.as_raw_fd(), LOOP_CTL_GET_FREE as _) };
         if devno < 0 {
+            error!("❌ Failed to get free loop device number");
             return Err(io::Error::last_os_error());
         }
 
         let path = format!("/dev/loop{}", devno);
+        info!("🔧 Creating new loop device at {}", path);
         let fd = OpenOptions::new().read(true).write(true).open(&path)?.into();
 
+        info!("✅ Successfully created loop device {}", path);
         Ok(LoopDevice { fd, path })
     }
 
@@ -50,23 +55,27 @@ impl LoopDevice {
     /// # Returns
     /// `io::Result<()>` indicating success or failure
     pub fn attach(&self, backing_file: &str) -> io::Result<()> {
+        debug!("📎 Attaching backing file {} to {}", backing_file, self.path);
         let f = fs::OpenOptions::new().read(true).write(true).open(backing_file)?;
 
         let file_fd = f.as_raw_fd();
         let our_fd = self.fd.as_raw_fd();
         let res = unsafe { libc::ioctl(our_fd, LOOP_SET_FD as _, file_fd) };
 
         if res < 0 {
+            error!("❌ Failed to attach backing file {}", backing_file);
             return Err(io::Error::last_os_error());
         }
 
         // Force loop device to immediately update by setting empty status
         let info: linux_raw_sys::loop_device::loop_info64 = unsafe { std::mem::zeroed() };
         let res = unsafe { libc::ioctl(our_fd, LOOP_SET_STATUS64 as _, &info) };
         if res < 0 {
+            warn!("⚠️ Failed to update loop device status");
             return Err(io::Error::last_os_error());
         }
 
+        info!("✅ Successfully attached backing file {}", backing_file);
         Ok(())
     }
 
@@ -75,11 +84,14 @@ impl LoopDevice {
     /// # Returns
     /// `io::Result<()>` indicating success or failure
     pub fn detach(&self) -> io::Result<()> {
+        debug!("🔓 Detaching backing file from {}", self.path);
         let res = unsafe { libc::ioctl(self.fd.as_raw_fd(), LOOP_CLR_FD as _, 0) };
         if res < 0 {
+            error!("❌ Failed to detach backing file from {}", self.path);
             return Err(io::Error::last_os_error());
         }
 
+        info!("✅ Successfully detached backing file from {}", self.path);
         Ok(())
     }
 }

crates/partitioning/src/sparsefile.rs

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+use log::info;
 use std::{fs, io, path::Path};
 
 /// Creates a sparse file at the specified path with the given size.
@@ -16,13 +17,17 @@ pub fn create<P>(path: P, size: u64) -> io::Result<()>
 where
     P: AsRef<Path>,
 {
+    info!("🗂️  Creating sparse file at {:?}", path.as_ref());
+
     let file = fs::OpenOptions::new()
         .write(true)
         .create(true)
         .truncate(true)
-        .open(path)?;
+        .open(&path)?;
 
+    info!("📝 Setting file size to {} bytes", size);
     file.set_len(size)?;
 
+    info!("✅ Successfully created sparse file");
     Ok(())
 }