Add more logging when storing images.

Author: veluca93

pixie-uefi/src/os/mod.rs

@@ -55,7 +55,7 @@ mod timer;
 
 pub use net::{TcpStream, UdpHandle, PACKET_SIZE};
 
-struct BytesFmt(u64);
+pub struct BytesFmt(pub u64);
 
 impl Display for BytesFmt {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -547,7 +547,7 @@ impl UefiOS {
             }
 
             os.messages.push_back((time, level, target.into(), msg));
-            const MAX_MESSAGES: usize = 5;
+            const MAX_MESSAGES: usize = 10;
             if os.messages.len() > MAX_MESSAGES {
                 os.messages.pop_front();
             }

pixie-uefi/src/parse_disk.rs

@@ -2,10 +2,12 @@ use crate::{
     os::{
         disk::Disk,
         error::{Error, Result},
+        BytesFmt,
     },
     store::ChunkInfo,
 };
 use alloc::vec::Vec;
+use log::info;
 
 fn le16(buf: &[u8], lo: usize) -> u16 {
     (0..2).map(|i| (buf[lo + i] as u16) << (8 * i)).sum()
@@ -244,12 +246,28 @@ async fn get_swap_chunks(disk: &Disk, start: u64, end: u64) -> Result<Option<Vec
 /// Returns chunks *relative to the start of the partition*.
 async fn parse_partition(disk: &Disk, start: u64, end: u64) -> Result<Vec<ChunkInfo>> {
     if let Some(chunks) = get_ext4_chunks(disk, start, end).await? {
+        info!(
+            "Ext4 partition with {} chunks of size {}",
+            chunks.len(),
+            BytesFmt(chunks.iter().map(|x| x.size as u64).sum::<u64>())
+        );
         Ok(chunks)
     } else if let Some(chunks) = get_ntfs_chunks(disk, start, end).await? {
+        info!(
+            "NTFS partition with {} chunks of size {}",
+            chunks.len(),
+            BytesFmt(chunks.iter().map(|x| x.size as u64).sum::<u64>())
+        );
         Ok(chunks)
     } else if let Some(chunks) = get_swap_chunks(disk, start, end).await? {
+        info!(
+            "Swap partition with {} chunks of size {}",
+            chunks.len(),
+            BytesFmt(chunks.iter().map(|x| x.size as u64).sum::<u64>())
+        );
         Ok(chunks)
     } else {
+        info!("Unknown partition type");
         Ok(vec![ChunkInfo {
             start: 0,
             size: (end - start) as usize,
@@ -268,6 +286,10 @@ async fn parse_gpt(disk: &mut Disk) -> Result<Option<Vec<ChunkInfo>>> {
     for partition in partitions {
         let begin = partition.byte_start as usize;
         let end = partition.byte_end as usize;
+        info!(
+            "Partition starting at {begin}, size {}",
+            BytesFmt((end - begin) as u64)
+        );
 
         if pos < begin {
             chunks.push(ChunkInfo {

pixie-uefi/src/store.rs

@@ -1,12 +1,13 @@
 use crate::{
     os::{
         error::{Error, Result},
-        mpsc, TcpStream, UefiOS,
+        mpsc, BytesFmt, TcpStream, UefiOS,
     },
     parse_disk, MIN_MEMORY,
 };
 use alloc::{rc::Rc, vec::Vec};
 use core::{cell::RefCell, net::SocketAddrV4};
+use log::info;
 use lz4_flex::compress;
 use pixie_shared::{Chunk, Image, Offset, TcpRequest, UdpRequest, MAX_CHUNK_SIZE};
 use uefi::proto::console::text::Color;
@@ -69,6 +70,10 @@ pub async fn store(os: UefiOS, server_address: SocketAddrV4) -> Result<()> {
 
     let mut disk = os.open_first_disk();
     let chunks = parse_disk::parse_disk(&mut disk).await?;
+    info!(
+        "Total size of chunks: {}",
+        BytesFmt(chunks.iter().map(|x| x.size as u64).sum::<u64>())
+    );
 
     // Split up chunks.
     let mut final_chunks = Vec::<ChunkInfo>::new();