partitioning: Start new crate for partitioning APIs

Right now we've simply got helpers to generate sparse files
and a new unsafe-bound API for managing loopback devices, so
that we can do safer testing for filesystem bits.

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

Author: ikeycode

crates/partitioning/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "partitioning"
+version = "0.1.0"
+edition = "2021"
+description = "A library for working directly with partitions"
+
+[dependencies]
+nix.workspace = true
+linux-raw-sys = { workspace = true, features = ["loop_device"] }

crates/partitioning/src/lib.rs

@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+pub mod loopback;
+pub mod sparsefile;

crates/partitioning/src/loopback.rs

@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::{
+    fs, io,
+    os::fd::{AsRawFd, OwnedFd},
+};
+
+use linux_raw_sys::loop_device::{LOOP_CLR_FD, LOOP_CTL_GET_FREE, LOOP_SET_FD, LOOP_SET_STATUS64};
+use nix::libc;
+
+/// Represents a loop device that can be used to mount files as block devices
+pub struct LoopDevice {
+    /// File descriptor for the loop device
+    fd: OwnedFd,
+    /// Path to the loop device (e.g. /dev/loop0)
+    pub path: String,
+}
+
+impl LoopDevice {
+    /// Creates a new loop device by obtaining the next available device number
+    /// from /dev/loop-control and opening the corresponding device file.
+    ///
+    /// # Returns
+    /// `io::Result<LoopDevice>` containing the new loop device on success
+    pub fn create() -> io::Result<Self> {
+        use std::fs::OpenOptions;
+
+        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 {
+            return Err(io::Error::last_os_error());
+        }
+
+        let path = format!("/dev/loop{}", devno);
+        let fd = OpenOptions::new().read(true).write(true).open(&path)?.into();
+
+        Ok(LoopDevice { fd, path })
+    }
+
+    /// Attaches a backing file to this loop device, allowing the file to be
+    /// accessed as a block device.
+    ///
+    /// # Arguments
+    /// * `backing_file` - Path to the file to attach
+    ///
+    /// # Returns
+    /// `io::Result<()>` indicating success or failure
+    pub fn attach(&self, backing_file: &str) -> io::Result<()> {
+        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 {
+            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 {
+            return Err(io::Error::last_os_error());
+        }
+
+        Ok(())
+    }
+
+    /// Detaches the current backing file from this loop device.
+    ///
+    /// # Returns
+    /// `io::Result<()>` indicating success or failure
+    pub fn detach(&self) -> io::Result<()> {
+        let res = unsafe { libc::ioctl(self.fd.as_raw_fd(), LOOP_CLR_FD as _, 0) };
+        if res < 0 {
+            return Err(io::Error::last_os_error());
+        }
+
+        Ok(())
+    }
+}

crates/partitioning/src/sparsefile.rs

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::{fs, io, path::Path};
+
+/// Creates a sparse file at the specified path with the given size.
+///
+/// # Arguments
+/// * `path` - Path where the sparse file should be created
+/// * `size` - Size in bytes for the sparse file
+///
+/// # Returns
+/// `io::Result<()>` indicating success or failure
+pub fn create<P>(path: P, size: u64) -> io::Result<()>
+where
+    P: AsRef<Path>,
+{
+    let file = fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(path)?;
+
+    file.set_len(size)?;
+
+    Ok(())
+}