Add logs to dstack-mr

Author: kvinwang

Cargo.lock

@@ -18,3 +18,4 @@ object.workspace = true
 hex-literal.workspace = true
 fs-err.workspace = true
 bon.workspace = true
+log.workspace = true

dstack-mr/Cargo.toml

@@ -15,3 +15,4 @@ hex.workspace = true
 dstack-types.workspace = true
 fs-err.workspace = true
 serde_json.workspace = true
+tracing-subscriber.workspace = true

dstack-mr/cli/Cargo.toml

@@ -18,6 +18,8 @@ enum Commands {
     Measure(MachineConfig),
 }
 
+type Bool = bool;
+
 #[derive(Parser)]
 struct MachineConfig {
     /// Number of CPUs
@@ -33,18 +35,18 @@ struct MachineConfig {
 
     /// Enable two-pass add pages
     #[arg(long, default_value = "true")]
-    two_pass_add_pages: bool,
+    two_pass_add_pages: Bool,
 
     /// Enable PIC
     #[arg(long, default_value = "true")]
-    pic: bool,
+    pic: Bool,
 
     /// Enable SMM
     #[arg(long, default_value = "false")]
-    smm: bool,
+    smm: Bool,
 
-    /// PCI hole64 size
-    #[arg(long)]
+    /// PCI hole64 size (accepts decimal or hex with 0x prefix)
+    #[arg(long, value_parser = parse_memory_size)]
     pci_hole64_size: Option<u64>,
 
     /// Enable hugepages
@@ -61,18 +63,20 @@ struct MachineConfig {
 
     /// Disable hotplug
     #[arg(long, default_value = "false")]
-    hotplug_off: bool,
+    hotplug_off: Bool,
 
     /// Enable root verity
     #[arg(long, default_value = "true")]
-    root_verity: bool,
+    root_verity: Bool,
 
     /// Output JSON
-    #[arg(long, default_value = "false")]
+    #[arg(long)]
     json: bool,
 }
 
 fn main() -> Result<()> {
+    tracing_subscriber::fmt::init();
+
     let cli = Cli::parse();
     match &cli.command {
         Commands::Measure(config) => {
@@ -123,20 +127,22 @@ fn main() -> Result<()> {
     Ok(())
 }
 
+/// Parse a memory size value that can be decimal or hexadecimal (with 0x prefix)
 fn parse_memory_size(s: &str) -> Result<u64> {
     let s = s.trim();
 
-    // Check if the string is empty
     if s.is_empty() {
         return Err(anyhow!("Empty memory size"));
     }
+    if s.starts_with("0x") || s.starts_with("0X") {
+        let hex_str = &s[2..];
+        return u64::from_str_radix(hex_str, 16)
+            .map_err(|e| anyhow!("Invalid hexadecimal value: {}", e));
+    }
 
-    // Handle bare number (bytes)
     if s.chars().all(|c| c.is_ascii_digit()) {
         return Ok(s.parse::<u64>()?);
     }
-
-    // Handle suffixes
     let len = s.len();
     let (num_part, suffix) = match s.chars().last().unwrap() {
         'k' | 'K' => (&s[0..len - 1], 1024u64),

dstack-mr/cli/src/main.rs

@@ -2,6 +2,7 @@
 //! translated from an original Go implementation.
 
 use anyhow::{bail, Context, Result};
+use log::debug;
 
 use crate::Machine;
 
@@ -141,6 +142,8 @@ impl Machine<'_> {
             ]);
         }
 
+        debug!("qemu command: {cmd:?}");
+
         // Execute the command and capture output
         let output = cmd
             .output()

dstack-mr/src/acpi.rs

@@ -1,4 +1,4 @@
-use crate::{measure_log, measure_sha384, num::read_le, utf16_encode};
+use crate::{measure_log, measure_sha384, num::read_le, utf16_encode, util::debug_print_log};
 use anyhow::{bail, Context, Result};
 use object::pe;
 use sha2::{Digest, Sha384};
@@ -213,6 +213,7 @@ pub(crate) fn measure_kernel(
         measure_sha384(b"Exit Boot Services Invocation"),
         measure_sha384(b"Exit Boot Services Returned with Success"),
     ];
+    debug_print_log("RTMR1", &rtmr1_log);
     Ok(measure_log(&rtmr1_log))
 }
 

dstack-mr/src/kernel.rs

@@ -1,8 +1,10 @@
 use crate::tdvf::Tdvf;
+use crate::util::debug_print_log;
 use crate::{kernel, TdxMeasurements};
 use crate::{measure_log, measure_sha384};
 use anyhow::{Context, Result};
 use fs_err as fs;
+use log::debug;
 
 #[derive(Debug, bon::Builder)]
 pub struct Machine<'a> {
@@ -26,6 +28,7 @@ pub struct Machine<'a> {
 
 impl Machine<'_> {
     pub fn measure(&self) -> Result<TdxMeasurements> {
+        debug!("measuring machine: {self:#?}");
         let fw_data = fs::read(self.firmware)?;
         let kernel_data = fs::read(self.kernel)?;
         let initrd_data = fs::read(self.initrd)?;
@@ -43,6 +46,7 @@ impl Machine<'_> {
             kernel::measure_cmdline(self.kernel_cmdline),
             measure_sha384(&initrd_data),
         ];
+        debug_print_log("RTMR2", &rtmr2_log);
         let rtmr2 = measure_log(&rtmr2_log);
 
         Ok(TdxMeasurements {

dstack-mr/src/machine.rs

@@ -3,6 +3,7 @@ use hex_literal::hex;
 use sha2::{Digest, Sha384};
 
 use crate::num::read_le;
+use crate::util::debug_print_log;
 use crate::{measure_log, measure_sha384, utf16_encode, Machine};
 
 const PAGE_SIZE: u64 = 0x1000;
@@ -252,6 +253,7 @@ impl<'a> Tdvf<'a> {
             measure_sha384(&[0x00, 0x00]), // BootOrder
             boot000_hash.to_vec(),
         ];
+        debug_print_log("RTMR0", &rtmr0_log);
         Ok(measure_log(&rtmr0_log))
     }
 

dstack-mr/src/tdvf.rs

@@ -1,3 +1,4 @@
+use log::debug;
 use sha2::{Digest, Sha384};
 
 /// Computes a SHA384 hash of the given data.
@@ -12,6 +13,12 @@ pub(crate) fn utf16_encode(input: &str) -> Vec<u8> {
         .collect()
 }
 
+pub(crate) fn debug_print_log(name: &str, log: &[Vec<u8>]) {
+    debug!("{name} event log:");
+    for (i, entry) in log.iter().enumerate() {
+        debug!("[{i}] digest: {}", hex::encode(entry));
+    }
+}
 /// Computes a measurement of the given RTMR event log.
 pub(crate) fn measure_log(log: &[Vec<u8>]) -> Vec<u8> {
     let mut mr = [0u8; 48]; // SHA384 output size