improve logging (sorry kids no emojis)

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

Author: ikeycode

crates/partitioning/src/blkpg.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use disks::{BasicDisk, DiskInit};
-use log::{debug, error, info, warn};
+use log::{debug, error, info};
 use std::{
     fs::File,
     io,
@@ -63,8 +63,8 @@ pub(crate) fn add_partition<F>(fd: F, partition_number: i32, start: i64, length:
 where
     F: AsRawFd,
 {
-    info!(
-        "➕ Adding partition {} (start: {}, length: {})",
+    debug!(
+        "Initiating partition addition - Number: {}, Start: {}, Length: {}",
         partition_number, start, length
     );
     let mut part = BlkpgPartition {
@@ -85,10 +85,10 @@ where
     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);
+        error!("Partition creation failed: {}", err);
         return Err(err);
     }
-    info!("✅ Successfully added partition {}", partition_number);
+    info!("Successfully created partition {}", partition_number);
     Ok(())
 }
 
@@ -104,7 +104,7 @@ pub(crate) fn delete_partition<F>(fd: F, partition_number: i32) -> io::Result<()
 where
     F: AsRawFd,
 {
-    warn!("🗑️ Attempting to delete partition {}", partition_number);
+    info!("Initiating deletion of partition {}", partition_number);
     let mut part = BlkpgPartition {
         start: 0,
         length: 0,
@@ -123,10 +123,10 @@ where
     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);
+        error!("Failed to delete partition {}: {}", partition_number, err);
         return Err(err);
     }
-    info!("✅ Successfully deleted partition {}", partition_number);
+    info!("Successfully removed partition {}", partition_number);
     Ok(())
 }
 
@@ -138,21 +138,17 @@ where
 /// # 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());
+    info!("Initiating GPT partition synchronization for {:?}", path.as_ref());
     let file = File::open(&path)?;
 
     // Read GPT table
-    debug!("📖 Reading GPT table...");
+    debug!("Reading GPT partition 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
-    );
+    info!("Located {} partitions (block size: {})", partitions.len(), block_size);
 
-    warn!("🗑️  Deleting existing partitions...");
+    debug!("Beginning partition cleanup process");
 
     // Find the disk for enumeration purposes
     let base_name = path
@@ -169,7 +165,7 @@ pub fn sync_gpt_partitions<P: AsRef<Path>>(path: P) -> Result<(), Error> {
     }
 
     // Add partitions from GPT
-    info!("➕ Adding new partitions from GPT...");
+    debug!("Beginning partition creation from GPT table");
     for (i, partition) in partitions.iter() {
         add_partition(
             file.as_fd(),
@@ -179,6 +175,6 @@ pub fn sync_gpt_partitions<P: AsRef<Path>>(path: P) -> Result<(), Error> {
         )?;
     }
 
-    info!("✨ GPT partition sync completed successfully");
+    info!("GPT partition synchronization completed successfully");
     Ok(())
 }

crates/partitioning/src/loopback.rs

@@ -8,7 +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 log::{debug, error, info};
 use nix::libc;
 
 /// Represents a loop device that can be used to mount files as block devices
@@ -28,21 +28,21 @@ impl LoopDevice {
     pub fn create() -> io::Result<Self> {
         use std::fs::OpenOptions;
 
-        debug!("🔄 Opening loop control device");
+        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");
+            error!("Failed to acquire free loop device number");
             return Err(io::Error::last_os_error());
         }
 
         let path = format!("/dev/loop{}", devno);
-        info!("🔧 Creating new loop device at {}", path);
+        debug!("Creating new loop device at {}", path);
         let fd = OpenOptions::new().read(true).write(true).open(&path)?.into();
 
-        info!("✅ Successfully created loop device {}", path);
+        info!("Successfully initialized loop device {}", path);
         Ok(LoopDevice { fd, path })
     }
 
@@ -55,27 +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);
+        debug!("Attempting to attach 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);
+            error!("Failed to attach backing file {} - OS error", 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");
+            error!("Failed to update loop device status - device may be in inconsistent state");
             return Err(io::Error::last_os_error());
         }
 
-        info!("✅ Successfully attached backing file {}", backing_file);
+        info!("Successfully attached backing file {} to loop device", backing_file);
         Ok(())
     }
 
@@ -84,14 +84,14 @@ impl LoopDevice {
     /// # Returns
     /// `io::Result<()>` indicating success or failure
     pub fn detach(&self) -> io::Result<()> {
-        debug!("🔓 Detaching backing file from {}", self.path);
+        debug!("Initiating detachment of 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);
+            error!("Failed to detach backing file from {} - OS error", self.path);
             return Err(io::Error::last_os_error());
         }
 
-        info!("✅ Successfully detached backing file from {}", self.path);
+        info!("Successfully detached backing file from loop device {}", self.path);
         Ok(())
     }
 }

crates/partitioning/src/sparsefile.rs

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

disk-test/src/main.rs

@@ -27,13 +27,13 @@ fn create_protective_mbr<P>(disk_size: u64, path: P) -> Result<(), Box<dyn std::
 where
     P: AsRef<Path>,
 {
-    debug!("🛡️  Creating protective MBR for disk of size {} bytes", disk_size);
+    info!("Creating protective MBR for disk of size {} bytes", disk_size);
     let mut gpt_device = fs::File::options().write(true).open(&path)?;
     let lb_size = (disk_size / 512) as u32;
     let lb_size = lb_size.saturating_sub(1); // subtract 1 for the MBR
     let mbr = ProtectiveMBR::with_lb_size(lb_size);
     mbr.overwrite_lba0(&mut gpt_device)?;
-    info!("✅ Successfully created protective MBR at {:?}", path.as_ref());
+    info!("Successfully created protective MBR at {:?}", path.as_ref());
     Ok(())
 }
 
@@ -54,7 +54,7 @@ fn create_default_partition_scheme<P>(path: P) -> Result<(), Box<dyn std::error:
 where
     P: AsRef<Path>,
 {
-    info!("💽 Creating default GPT partition scheme on {:?}", path.as_ref());
+    info!("Creating default GPT partition scheme on {:?}", path.as_ref());
 
     // Configure and create GPT disk
     let gpt_config = GptConfig::new()
@@ -63,24 +63,24 @@ where
 
     let mut gpt_disk = gpt_config.create(&path)?;
 
-    debug!("📝 Creating EFI System Partition (256MB)");
+    info!("Creating EFI System Partition (256MB)");
     gpt_disk.add_partition("", 256 * 1024 * 1024, partition_types::EFI, 0, None)?;
 
-    debug!("📝 Creating Boot Partition (2GB)");
+    info!("Creating Boot Partition (2GB)");
     gpt_disk.add_partition("", 2 * 1024 * 1024 * 1024, partition_types::FREEDESK_BOOT, 0, None)?;
 
-    debug!("📝 Creating Swap Partition (4GB)");
+    info!("Creating Swap Partition (4GB)");
     gpt_disk.add_partition("", 4 * 1024 * 1024 * 1024, partition_types::LINUX_SWAP, 0, None)?;
 
     // Use remaining space for root partition
     let sectors = gpt_disk.find_free_sectors();
-    debug!("📊 Available sectors: {sectors:?}");
+    debug!("Available sectors: {sectors:?}");
     let (_, length) = sectors.iter().find(|(_, l)| *l > 0).unwrap();
-    debug!("📝 Creating Root Partition ({}MB)", (length * 512) / (1024 * 1024));
+    info!("Creating Root Partition ({}MB)", (length * 512) / (1024 * 1024));
     gpt_disk.add_partition("", *length * 512, partition_types::LINUX_FS, 0, None)?;
     let _ = gpt_disk.write()?;
 
-    info!("✅ Successfully created partition scheme");
+    info!("Successfully created partition scheme");
     Ok(())
 }
 
@@ -90,31 +90,31 @@ where
 /// - Partitioning with GPT
 /// - Enumerating block devices
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    pretty_env_logger::formatted_builder()
-        .filter_level(log::LevelFilter::Trace)
+    pretty_env_logger::formatted_timed_builder()
+        .filter_level(log::LevelFilter::Info)
         .init();
-    info!("🚀 Starting disk partitioning demo");
+    info!("Starting disk partitioning demo");
 
     // Create 35GB sparse image file and attach to loopback device
     let image_size = 35 * 1024 * 1024 * 1024;
-    info!("📁 Creating {}GB sparse image file", image_size / (1024 * 1024 * 1024));
+    info!("Creating {}GB sparse image file", image_size / (1024 * 1024 * 1024));
     sparsefile::create("hello.world", image_size)?;
 
-    debug!("🔄 Setting up loopback device");
+    info!("Setting up loopback device");
     let device = loopback::LoopDevice::create()?;
     device.attach("hello.world")?;
-    info!("💫 Loop device created at: {}", &device.path);
+    info!("Loop device created at: {}", &device.path);
 
     // Initialize disk with protective MBR and partition scheme
     create_protective_mbr(image_size, "hello.world")?;
     create_default_partition_scheme("hello.world")?;
 
     // Notify kernel of partition table changes
-    debug!("🔄 Syncing partition table changes");
+    debug!("Syncing partition table changes");
     blkpg::sync_gpt_partitions(&device.path)?;
 
     // Get list of all loopback devices
-    info!("🔍 Discovering block devices");
+    debug!("Discovering block devices");
     let loop_devices = BlockDevice::discover()?
         .into_iter()
         .filter_map(|device| {
@@ -127,12 +127,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .collect::<Vec<_>>();
 
     // Display information about discovered devices
-    info!("📋 Device information:");
+    info!("Device information:");
     for loop_device in loop_devices {
         if let Some(file) = loop_device.file_path() {
             if let Some(disk) = loop_device.disk() {
                 info!(
-                    "💾 Loopback device: {} (backing file: {})",
+                    "Loopback device: {} (backing file: {})",
                     loop_device.name(),
                     file.display()
                 );
@@ -145,10 +145,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     // Clean up resources
-    debug!("🧹 Cleaning up resources");
+    info!("Cleaning up resources");
     device.detach()?;
     //fs::remove_file("hello.world")?;
 
-    info!("✨ Demo completed successfully");
+    info!("Demo completed successfully");
     Ok(())
 }